oracle-livelabs
diff --git a/‎dev-guide-ai-finance/build/build.md‎
Lines changed: 33 additions & 25 deletions b/‎dev-guide-ai-finance/build/build.md‎
Lines changed: 33 additions & 25 deletions
diff --git a/‎dev-guide-ai-finance/codingbasics/codingbasics.md‎
Lines changed: 29 additions & 23 deletions b/‎dev-guide-ai-finance/codingbasics/codingbasics.md‎
Lines changed: 29 additions & 23 deletions
diff --git a/‎dev-guide-ai-finance/connect-to-env/connect-to-env.md‎
Lines changed: 41 additions & 17 deletions b/‎dev-guide-ai-finance/connect-to-env/connect-to-env.md‎
Lines changed: 41 additions & 17 deletions
@@ -2,9 +2,13 @@
 
 ## Introduction
 
-In this lab, you will build a loan recommendation system powered by Oracle Database 23ai and OCI Generative AI. You will connect to a Oracle Database 23ai, explore customer data, extract relevant insights, and use a Large Language Model (LLM) to generate personalized loan suggestions. The system combines AI with OCI Generative AI to provide personalized loan recommendations. This system integrates AI capabilities with Oracle's robust database technology to deliver targeted financial recommendations.
+At SeerEquities, the data team is building a GenAI-powered loan assistant to support faster, more accurate loan approvals. The goal: reduce manual effort by using **retrieval-augmented generation (RAG)** and **LLMs** directly inside a governed Oracle Database 23ai environment.
 
-This lab uses some of the basic coding samples you created in lab 3, such as cursor.execute and more.
+In this lab, you'll build that assistant from the ground up.
+
+You’ll connect to Oracle Database 23ai, explore customer data, use Oracle’s built-in embedding tools to vectorize content, and query it using AI Vector Search. Finally, you’ll feed results into a **Generative AI model from OCI** to generate contextual recommendations.
+
+> 💡 Everything runs securely inside the database—no need to move data to external tools or vector stores. Only the enriched context is provided securely to OCI Generative AI services.
 
 Estimated Time: 30 minutes
 
@@ -15,33 +19,37 @@ To get things started we invite you to watch this video and see the lab in actio
 
 ### Objectives
 
-* Build the complete loan approval application as seen in lab 1
-* Use OCI Generative AI to generate personalized loan recommendations
-* Use Python to connect to an Oracle Database 23ai instance and run queries
-* Explore customer data and extract relevant information
+- Build a complete RAG workflow using Python and Oracle Database 23ai  
+- Connect to the database, prepare customer and loan data  
+- Use `dbms_vector_chain` to create embeddings  
+- Perform similarity search using `VECTOR_DISTANCE()`  
+- Generate contextual loan recommendations using OCI Generative AI  
 
 ### Prerequisites
 
 This lab assumes you have:
 
-* An Oracle Cloud account
-* Completed lab 1: Run the demo
-* Completed lab 2: Connect to the Development Environment
+- Oracle Cloud account  
+- Completed:
+  - Connect to the Development Environment: Environment Setup  
+  - Coding Basics on Oracle Database 23ai: Coding Basics
+
 
-## Task 1: Build the application in Jupyter Notebook
->💡**Note**: Review Lab 2: Connect to the Development Environment for instructions on accessing JupyterLab.
+## Task 1: Launch a Jupyter Notebook
 
-1. Click the blue "+". This will open the Launcher. 
+>💡**Note**: Review **Connect to the Development Environment** for instructions on accessing JupyterLab.
+
+1. Click the blue **+** to open the Launcher  
 
     ![Open Launcher](./images/launcher.png " ")
 
 
-2. Open a new **Jupyter Notebook** by clicking on **Python(ipykernel)** notebook.
+2. Select **Python (ipykernel)** to open a new notebook
 
     ![Open Jupyter Notebook](./images/open-new-notebook.png " ")
 
 
-## Task 2: Connect to the database using oracledb Python driver
+## Task 2: Connect to Oracle Database 23ai
 
 1. Copy the following code block into an empty cell in your notebook. This code block imports the `oracledb` Python driver and other libraries. 
 
@@ -78,21 +86,20 @@ This lab assumes you have:
     ![Connect to Database](./images/connect-to-db.png " ")
 
 
-## Task 3: Create tables in the database
+## Task 3: Create database tables
 
-1. Copy the following code block into the next empty cell in your notebook. This will create all tables in the database. 
+1. Run the following cell to create your tables and populate them with sample data: 
 
     ```python
     <copy>
     exec(open("db_setup.py").read())
     </copy>
     ```
-2. Run the code block to create all tables in the database. 
 
     ![Create Tables](./images/create-tables.png " ") 
 
 
-## Task 4: Create a function to retrieve data from the database
+## Task 4: Fetch and display a customer profile
 
 With the database ready, you will query customer data from the clients_dv JSON duality view. This view merges data from `CLIENTS`, `LOAN_APPLICATIONS`, and `CLIENT_DEBT` into a single JSON object, streamlining access to related records for AI-driven analysis.
 
@@ -408,19 +415,20 @@ Now that the recommendations are vectorized, we can process a user’s question:
 
     ![rag](./images/rag.png " ")
 
-## Summary
+## Conclusion
 
 Congratulations! You implemented a RAG process in Oracle Database 23ai using Python.
 
 To summarize:
 
-* You created a function to connect to Oracle Database 23ai using the Oracle Python driver `oracledb`.
-* You created a function to retrieve customer data.
-* You created a function to connect to OCI Generative AI and create a first recommendation.
-* You created a function to create embeddings of the customer data using Oracle Database 23ai.
-* And finally, you implemented a RAG process in Oracle Database 23ai using Python.
+In this lab, you built the foundation of the SeerEquities GenAI Loan Assistant:
+
+✅ Pulled customer data from JSON Duality Views
+✅ Used Oracle Database 23ai to create and search vector embeddings
+✅ Queried embedded chunks using AI Vector Search
+✅ Generated and refined answers using OCI Generative AI
 
-Congratulations, you completed the lab!
+This RAG workflow now powers contextual conversations between loan officers and the system—with no external vector store or duplicated pipeline.
 
 You may now proceed to the next lab.
 
 
@@ -2,7 +2,20 @@
 
 ## Introduction
 
-In this hands-on lab, you will learn the basics of working with Oracle Database 23ai using Python. You will connect to the database with both `oracledb` and `pymongo`, create and query tables, and build JSON Duality Views. You will also explore Oracle’s Mongo API to query and update data using a familiar document model. For organizations already using MongoDB-like applications, the Oracle MongoDB API enables a smoother transition and integration with existing code, tools, or drivers—while consolidating everything in Oracle’s converged platform.
+
+At SeerEquities, developers are building a next-generation loan approval system that needs to combine enterprise-grade data governance with modern AI capabilities. But before GenAI or vector search can be applied, one thing must be true:
+
+👉 The data must be in the right shape — accessible, trustworthy, and programmable.
+
+In this lab, you’ll act as a developer on the SeerEquities data team. Your job is to build the foundational logic that powers the application’s intelligence layer. That means:
+
+- Creating and querying relational tables that represent real loan and customer data using Python
+- Converting that data into **JSON documents** using **JSON Duality Views**
+- Using **MongoDB-style syntax** via Oracle’s Mongo API to interact with the same data — without needing to duplicate or move it
+
+These capabilities make Oracle Database 23ai a **developer-friendly**, **multi-model platform**. You’ll write less glue code, eliminate data movement, and stay focused on the real task: powering intelligent loan workflows.
+
+> 💡 Everything you implement here becomes the data foundation for Retrieval-Augmented Generation (RAG) and AI Vector Search in upcoming labs.
 
 Estimated Time: 30 minutes
 
@@ -12,33 +25,26 @@ To get things started we invite you to watch this video and see the lab in actio
 
 ### Objectives
 
-* Learn basic Python coding concepts with Oracle Database 23ai
-  * Connect to Oracle Database 23ai
-  * Create tables
-  * Insert & query data
-  * Create a JSON Duality View using Python
-  * Connect to database using `pymongo` and start using Oracle's Mongo API
-  * Query data using Oracle's Mongo API
-  * Update data using Oracle's Mongo API
+- Connect to Oracle Database 23ai using Python  
+- Create and query relational data  
+- Use JSON Duality Views to work with relational tables as JSON  
+- Query and update the same data using MongoDB-style syntax
 
 ### Prerequisites
 
 This lab assumes you have:
 
-* An Oracle account to submit a LiveLabs Sandbox reservation.
-
-* Completed Lab 2: Connect to the development environment
-
-* Basic knowledge of Python.
-
-* Basic knowledge of Oracle Database, i.e., how to run queries.
+- An Oracle account with LiveLabs access  
+- Completion of **Lab 1: Connect to the Development Environment**  
+- Basic familiarity with Python and SQL
 
 
 ## Task 1: Create a new Jupyter Notebook
 
 All of the coding examples will be executed in a new Jupyter Notebook.
 
-1. Open a new **Jupyter Notebook** by clicking on **Python(ipykernel)** notebook.
+1. In **JupyterLab**, click the blue **+** to open the Launcher  
+2. Start a new **Python (ipykernel)** notebook
 
     ![Open Jupyter Notebook](./images/open-new-notebook.png " ")
 
@@ -69,14 +75,14 @@ In this first task, you will connect to an Oracle Database 23ai instance using O
     cursor = connection.cursor()
     </copy>
     ```
+
 2. Execute the cell by entering **shift + enter** or clicking on the play button.
 
 3. You should see a message that says "Connection successful!" in your notebook. If you do not, check the credentials and try again. 
 
     ![connect](./images/connect.png " ")
 
->**Note:** The last line, `cursor = connection.cursor()`, creates a cursor object from the established Oracle database connection. A cursor acts as a control structure that enables the execution of SQL queries and retrieval of results from the database. It is essential for sending SQL commands, fetching data, and iterating through query results. We will be using the cursor object in later steps of this lab. The object persists in the notebook session, so you can use it in subsequent cells without re-establishing the connection. 
-
+>**Note:** The last line, `cursor = connection.cursor()`, creates a cursor object from the established Oracle database connection. A cursor acts as a control structure that enables the execution of SQL queries and retrieval of results from the database. It is essential for sending SQL commands, fetching data, and iterating through query results. We will be using the cursor object in later steps of this lab. The object persists in the notebook session, so you can use it in subsequent cells without re-establishing the connection.
 
 ## Task 3: Create tables and insert data
 
@@ -478,13 +484,13 @@ The final step in our basic coding tour with Python and the Oracle Database 23ai
 
     🔴 **`df.head()`** - This is a method that returns that returns the result of the query including the column names. 
 
-## Summary
+## Conclusion
 
-In this lab, we learned how to use Python and Oracle's Python driver `oracledb` to interact with Oracle Database 23ai's new features. You learned how to user the `cursor` object to execute SQL queries. Using the `cursor` object, you created a **JSON Duality View** and you even used some JSON functions to query documents using SQL syntax. Then, you also learned how to connect to the database using `pymongo` and retrieve data from a table in the database using **MongoDB syntax**. You created functions to update the **JSON Duality View** and you learned how these updates are also reflected in the underlying relational database tables.
+As a developer at SeerEquities, you've just built the foundation for a GenAI-powered loan approval system. We learned how to use Python and Oracle's Python driver `oracledb` to interact with Oracle Database 23ai's new features. You learned how to user the `cursor` object to execute SQL queries. Using the `cursor` object, you created a **JSON Duality View** and you even used some JSON functions to query documents using SQL syntax. Then, you also learned how to connect to the database using `pymongo` and retrieve data from a table in the database using **MongoDB syntax**. You created functions to update the **JSON Duality View** and you learned how these updates are also reflected in the underlying relational database tables.
 
-In the next labs, you will see several of the coding principles learned and even more.  
+This architecture eliminates the need for duplicating data across platforms and simplifies how developers build AI-ready applications. Whether you're calling SQL, working with JSON, or speaking Mongo, you're always working with a single source of truth inside the Oracle Database.
 
-You are now ready to implement you a RAG process using Oracle Database 23ai's new features!
+In the next lab, you'll build on this foundation to implement Retrieval-Augmented Generation (RAG), create vector embeddings, and generate personalized loan recommendations with Oracle 23ai and OCI Generative AI.
 
 ## Acknowledgements
 * **Authors** - Linda Foinding, Kevin Lazarz
 
@@ -2,7 +2,12 @@
 
 ## Introduction
 
-In this lab, we will show you how to connect to the development environment. We are using JupyterLab as our development environment, which is a web-based application that allows you to write and run code on your browser. You can use this environment to create notebooks, edit files, and run Python scripts.
+In this short lab, you’ll launch the JupyterLab-based development environment used throughout the workshop. JupyterLab runs entirely in your browser and allows you to write and test Python code that interacts directly with Oracle Database 23ai.
+
+This is the same environment used by the SeerEquities data team to build the AI loan assistant.
+
+> 💡 You only need to complete this once. In the next labs, you'll jump straight into hands-on coding. Remember to come back to this lab in case you need you closed the browser window and need to access JupyterLab again.
+
 
 Estimated Time: 5 minutes
 
@@ -12,43 +17,62 @@ To get things started we invite you to watch this video and see the lab in actio
 
 ### Objective
 
-* Login to JupyterLab
+- Access the JupyterLab environment
+- Log in using provided credentials
+- Get familiar with basic Jupyter features
 
 ## Task 1: Login to JupyterLab
 
-1. To navigate to the development environment, click **View Login Info**. Copy the Development IDE Login Password. Click the Start Development IDE link.
-
+1. In the top left of your lab page, click **View Login Info**.  
+2. Copy the **Development IDE Login Password**.
+3. Click the **Start Development IDE** link.
+   
     ![Open Development Environment](./images/dev-env.png =50%x*)
 
-2. Paste in the Development IDE Login Password that you copied in the previous step. Click **Login**.
+4. Paste in the password and click **Login**.
 
     ![Login](./images/jupyter-login.png " ")
 
-## Task 2: Get familiar with the development environment
+You’re now in the development environment.
+
+## Task 2: Explore JupyterLab
+
+JupyterLab is where you’ll write, run, and test Python code that connects to Oracle Database 23ai. Here are the key parts:
+
+**File browser (1):** Use this panel to open notebooks, scripts, and other files. Right-click for actions like rename or delete.
+
 
-1. Review the different elements in JupyterLab:
+**Launcher:** From here, you can start:
+- **Python notebooks (2)** for running code
+- **Terminals (3)** ** for command-line tasks
 
-    **File browser:** The file browser organizes and manages files within the JupyterLab workspace. It supports drag-and-drop file uploads, file creation, renaming, and deletion. Users can open notebooks, terminals, and text editors directly from the browser. Navigation is fast and intuitive, with breadcrumbs and context menus that surface relevant actions. Users can right-click files to access options like duplicate, shutdown kernel, or open with a specific editor.
+![JupyterLab Launcher](./images/jupyter.png " ")
 
-    **Launcher:** The launcher offers a streamlined entry point for starting new activities. Users can create Jupyter Notebooks for interactive coding with live code execution, visualizations, and rich markdown. The terminal provides direct shell access, enabling command-line operations within the JupyterLab environment. These two tools form the core of most workflows, supporting both interactive analysis and system-level tasks from a single interface.
+## Task 3: Working with Jupyter Notebooks
 
-    ![JupyterLab Launcher](./images/jupyter.png " ")
+You’ll use notebooks for every lab in this workshop. Each notebook is made up of **cells**:
 
-## Task 3: Get familiar with Jupyter Notebooks
+- **Markdown cells** hold instructions and explanations
+- **Code cells** contain executable Python
 
-You will use a Jupyter Notebook in JupyterLab to build and test the loan recommendation system. If you are new to notebooks, the following tips will help you get started and work smoothly.
+To run a code cell:
+- Press **Shift + Enter**
+- Or click the **Run** button in the toolbar
 
-1. **Executing Code Blocks**: You can run code in two simple ways: press **Shift+Enter** to execute and move to the next cell, or click the **Play/Execute** button in the menu bar at the top of this tab. Both methods work interchangeably.
+While a cell is running, you’ll see `[*]`. When it finishes, it changes to a number like `[3]`.
 
-2. **Block Types**: Instructions and code are separated into **their own blocks**. Instructions are in markdown (like this cell), while code is in executable Python blocks. If you accidentally run an instruction block, it’ll just skip to the next cell—no harm done!
+![JupyterLab blocks](./images/block.png " ")
 
-3. **Running Indicators**: When you run a code block, its label changes from `[ ]` (empty) or `[1]` (a number) to `[*]`. The asterisk (`*`) means it’s processing. Wait until it switches back to a number (e.g., `[2]`) before moving on, ensuring the operation is complete.
+> 🛠 If a cell throws an error, double-check the code or rerun the previous steps.
 
-4. **Output & Warnings**: Below each code cell, output appears after execution. This can include results, visualizations, or messages. Warnings may show up—these are usually informational, such as notices about deprecated features. Unless an error halts execution, users can continue without making changes. If you see a error, review the code for any issues and make changes accordingly and try executing the cell again.
 
-    ![JupyterLab blocks](./images/block.png " ")
+## Conclusion
 
+You’ve now logged into the cloud-based development environment where all coding will take place.
 
+✅ You can access JupyterLab in your browser  
+✅ You understand how to open and run notebooks  
+✅ You’re ready to start interacting with Oracle Database 23ai  
 
 ## Acknowledgements
 * **Author** - Kamryn Vinson