diff --git a/data-fundamentals-dev-rel/connect-to-env/connect-to-env.md b/data-fundamentals-dev-rel/connect-to-env/connect-to-env.md new file mode 100644 index 000000000..29e9bd6c7 --- /dev/null +++ b/data-fundamentals-dev-rel/connect-to-env/connect-to-env.md @@ -0,0 +1,58 @@ +# Connect to the Development Environment + +## Introduction + +In this lab, you'll learn how to access the web-based JupyterLab development environment, where you can write and run Python code directly in your browser. You'll log in, and get ready to start coding in a hands-on environment. + +Estimated Time: 5 minutes + +### Objectives + +* Login to JupyterLab server +* Run Jupyter Notebook + +## Task 1: Login to JupyterLab Server + +1. To navigate to the development environment, click **View Login Info**. Copy the Development IDE Login Password. 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**. + + ![JupyterLab server login](./images/jupyter-login.png " ") + +1. Select **`notebooks/data_fundamentals`** directory to open it. Double click on file **`data_fundamentals_lab.ipynb`** and it will open in the the panel on the right. + + ![Open Launcher](./images/launcher.png " ") + +## Task 2: Learn to use the components of Unified Model Theory (UMT) + +You will use a Jupyter Notebook in a JupyterLab server to build and test database queries. If you are new to notebooks, the following tips will help you get started and work smoothly. + +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. + +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! + +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. + +4. **Output & Warnings**: Below each code cell, output appears during and 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. + + **NOTE:** Look for **green text** as in the image below where it says "Connected successfully!". Many cells will have different message, but the final successful one should always be green. When you see the green text, the cell completed. For some longer running cells, this is important to watch for. + + ![JupyterLab cell example](./images/block.png " ") + +## Task 3: Hybrid Vector Search lab section. **(Optional)** + +In the lab, there is a section that is hidden by default. If there is extra time, you are welcome to unhide it and complete this section about Hybrid AI search (vector search) where you see how Oracle's Hybrid Vector Search combines traditional lexical search with vector search. + +In this task, you can weight each search type differently depending on the application needs and see the output depending on the settings. + +## Conclusion + +In this lab you logged into the **IDE Development Environment** for Jupyter Labs. You launched the **`data_fundamentals_lab.ipynb`** notebook and worked through the notebook to learn about the fundamental data building blocks for AI application development. + +Make sure you take the quiz by clicking on **Take the quiz!** link on the left nav bar. + +## Acknowledgements +* **Authors** - Kirk Kirkconnell +* **Last Updated By/Date** - Kirk Kirkconnell, June 2026 diff --git a/data-fundamentals-dev-rel/connect-to-env/images/block.png b/data-fundamentals-dev-rel/connect-to-env/images/block.png new file mode 100644 index 000000000..02ad04838 Binary files /dev/null and b/data-fundamentals-dev-rel/connect-to-env/images/block.png differ diff --git a/data-fundamentals-dev-rel/connect-to-env/images/dev-env.png b/data-fundamentals-dev-rel/connect-to-env/images/dev-env.png new file mode 100644 index 000000000..e63e81594 Binary files /dev/null and b/data-fundamentals-dev-rel/connect-to-env/images/dev-env.png differ diff --git a/data-fundamentals-dev-rel/connect-to-env/images/jupyter-login.png b/data-fundamentals-dev-rel/connect-to-env/images/jupyter-login.png new file mode 100644 index 000000000..c3ba1fde6 Binary files /dev/null and b/data-fundamentals-dev-rel/connect-to-env/images/jupyter-login.png differ diff --git a/data-fundamentals-dev-rel/connect-to-env/images/launcher.png b/data-fundamentals-dev-rel/connect-to-env/images/launcher.png new file mode 100644 index 000000000..84badbe7f Binary files /dev/null and b/data-fundamentals-dev-rel/connect-to-env/images/launcher.png differ diff --git a/data-fundamentals-dev-rel/introduction/introduction.md b/data-fundamentals-dev-rel/introduction/introduction.md new file mode 100644 index 000000000..864898f52 --- /dev/null +++ b/data-fundamentals-dev-rel/introduction/introduction.md @@ -0,0 +1,53 @@ +# Introduction + +## About this Workshop + +In this lab, we'll interact with a data set from an application named Prism CityOps. It's an application used by the city of Kirkland to monitor and manage city infrastrucuter such as ongoing maintenance, active monitoring via IoT devices, crew dispatch, record keeping, and more. + +You'll utilize a Jupyter Notebook with real Python code, completing real activities, and using aspects of Unified Model Theory (UMT) to present data in various forms, from JSON documents, to graph traversals with visual of those relationships, and perform AI search via vector data, all within Oracle AI Database. + +Estimated Workshop Time: 50 - 60 minutes + +✅ **Overview of Labs** + +In the next labs, you'll connect to your JupyterLab environment and work through a data fundamentals notebook built around the Prism CityOps dataset. You'll inspect the same operational data through relational tables, JSON, graph, and vector representations, then use Oracle AI Database to generate embeddings, run Vector Search, and compare search patterns. Labs 1 and 2 will be in the morning session, and Labs 3 and 4 will be completed in the afternoon sessions. + +* **Lab 1 – Connect to your environment** +Log in to the JupyterLab IDE where you’ll run Python code. + +* **Lab 2 – Explore the Prism data foundation** +Open the data fundamentals notebook, verify your database connection, and explore the Prism data model. You'll query relational tables, inspect JSON document-style data, follow graph relationships with SQL/PGQ, and see how criticality, maintenance logs, sensors, assets, and incidents connect across the model. + +* **Lab 3 – Generate and search vector embeddings** +Use an in-database ONNX embedding model to create vectors without moving data out of Oracle AI Database. You'll insert new maintenance information, vectorize it, inspect the vector index, and run both broad and targeted similarity searches for incidents, procedures, and operational context. + +* **Lab 4 – Combine data shapes in unified AI-ready queries** +Bring the data model together with SQL that returns table output, JSON output, graph-driven results, and vector search matches from the same database. If time allows, you'll also try optional Hybrid Vector Search to compare vector-only, text-only, and combined ranking strategies. + +By the end, you'll understand how Oracle AI Database can support AI application development by keeping operational data, graph relationships, JSON structures, embeddings, vector indexes, and search logic close together in one platform. + +### Objectives + +* Connect to Oracle AI Database from JupyterLab and verify the lab environment is ready. +* Explore the Prism CityOps data model across relational tables, JSON data, and graph relationships. +* Use SQL and SQL/PGQ to analyze infrastructure assets, incidents, sensors, maintenance logs, and operational criticality. +* Generate vector embeddings inside Oracle AI Database with an in-database ONNX model. +* Inspect vector indexes and run similarity searches over operational records and procedures. +* Combine relational, JSON, graph, and vector search results in AI-ready SQL queries. +* Compare vector-only, text-only, and hybrid search strategies when completing the optional Hybrid Vector Search section. + +### Prerequisites + +This lab assumes you have: + +* An Oracle account to submit your LiveLabs Sandbox reservation. +* Basic knowledge of coding and Python. +* Basic knowledge of Oracle Database, i.e., how to run queries. + +## Learn More + +* [Oracle AI Database Documentation](https://docs.oracle.com/en/database/oracle/oracle-database/26/) + +## Acknowledgements +* **Authors** - Kirk Kirkconnell +* **Last Updated By/Date** - Kirk Kirkconnell, June 2026 diff --git a/data-fundamentals-dev-rel/quiz/images/badge.png b/data-fundamentals-dev-rel/quiz/images/badge.png new file mode 100644 index 000000000..b7d752677 Binary files /dev/null and b/data-fundamentals-dev-rel/quiz/images/badge.png differ diff --git a/data-fundamentals-dev-rel/quiz/quiz.md b/data-fundamentals-dev-rel/quiz/quiz.md new file mode 100644 index 000000000..71f1707f4 --- /dev/null +++ b/data-fundamentals-dev-rel/quiz/quiz.md @@ -0,0 +1,84 @@ +# Quiz + +## Introduction + +Test your knowledge of building a RAG and agentic! This quiz covers key concepts from the lab including Vector Search, embeddings, Python integration, and AI-powered recommendation systems. + +Estimated Time: 5 minutes + +```quiz-config + passing: 80 + badge: images/badge.png +``` + +### Objectives + +* Pass the quiz and get your "Data fundamentals for AI application developement" skills badge! + +### Quiz Questions + +```quiz score +Q: What is the primary purpose of RAG (Retrieval-Augmented Generation)? +- To replace the need for a database entirely +- To build a better augmented +* To retrieve and attach physical hardware components to an LLM, thus making your own ghost in the shell. Major Kusanagi would be so proud +* To augment an LLM's responses by retrieving and providing relevant data that exists outside its training knowledge + +Q: True or False: Oracle AI Database enables you to create vector embeddings directly within the database. +* True +- False +- Shmaybe + +Q: Which Python library is used to connect to Oracle AI Database in the hands-on lab? +- psycopg2 +* oracledb +- pymongo +- sqlalchemy +> The oracledb library can be easily grabbed using `pip install oracledb` + +Q: What is the default category of vector indexes in Oracle AI Database? +- IVF (Inverted File) +* HNSW (Hierarchical Navigable Small Worlds ) +- Token Ring +- OSON + +Q: What's likely the best data type to store embeddings in Oracle AI Database? +- NUMBER +- BLOBOFREGRET +* VECTOR +- VARCHAR2 + +Q: What does the VECTOR_CHUNKS function do? +- It's a hidden function that creates fresh, chunky dog food ondemand +- Encrypts sensitive customer data +* Splits text into smaller chunks to generate vector embeddings that can be used with vector indexes or hybrid vector indexes. +- Creates backup copies of database tables in bite-sized chunks + +Q: Which database feature combines data from one or more relational tables, but projects the data as a JSON document? +* JSON Relational Duality View +- Materialized View +- Temporary Table +- Stored Procedure +> JSON Relational Duality Views enable you to interact with data in one or more relational tables, but read and write as native JSON document. + +Q: True or False: You can query JSON, relational tables, traverse graphs, and search vector data all in one SQL statement? +* True +- False +> It's true! In Oracle AI database, you can combine multiple data modalities as you need to. + +Q: What's the likely data type you should store a JSON document in Oracle? +- CLOB +- VARCHAR2 +* JSON +> Your default for storing JSON should likely be a JSON data type, but it really depends on how large of a document you're storing and your use case. + +Q: How does Cosine similarity measure distance? +- It gets out a tape measure and... +- It measures concise distance between vectors +* It measures the angle between vectors + +``` + +## Acknowledgements +* **Authors** - Kirk Kirkconnell +* **Last Updated By/Date** - Kirk Kirkconnell, January 2026 diff --git a/data-fundamentals-dev-rel/workshops/sandbox/index.html b/data-fundamentals-dev-rel/workshops/sandbox/index.html new file mode 100644 index 000000000..aebbdda4a --- /dev/null +++ b/data-fundamentals-dev-rel/workshops/sandbox/index.html @@ -0,0 +1,63 @@ + + + + + + + + + Oracle LiveLabs + + + + + + + + + + + + + +
+
+
+
+
+
+
+
+ + + + + diff --git a/data-fundamentals-dev-rel/workshops/sandbox/manifest.json b/data-fundamentals-dev-rel/workshops/sandbox/manifest.json new file mode 100644 index 000000000..1def72137 --- /dev/null +++ b/data-fundamentals-dev-rel/workshops/sandbox/manifest.json @@ -0,0 +1,26 @@ +{ + "workshoptitle": "From Zero to Hero: Data Fundamentals of AI Application Development", + "help": "livelabs-help-database_us@oracle.com", + "tutorials": [ + { + "title": "Introduction", + "description": "The Introduction is always first. The title and contents menu title match for the Introduction.", + "filename": "../../introduction/introduction.md" + }, + { + "title": "Connect to the Development Environment", + "description": "This is a step-by-step guide showcasing how the hands-on lab instance is navigated", + "filename": "../../connect-to-env/connect-to-env.md" + }, + { + "title": "Take the quiz!", + "description": "This is a step-by-step guide showcasing how the hands-on lab instance is navigated", + "filename": "../../quiz/quiz.md" + }, + { + "title": "Need Help?", + "description": "Solutions to Common Problems and Directions for Receiving Live Help", + "filename": "https://livelabs.oracle.com/cdn/common/labs/need-help/need-help-freetier.md" + } + ] +} \ No newline at end of file diff --git a/dev-rel-agent-memory/connect-to-env/connect-to-env.md b/dev-rel-agent-memory/connect-to-env/connect-to-env.md new file mode 100644 index 000000000..e56996ea1 --- /dev/null +++ b/dev-rel-agent-memory/connect-to-env/connect-to-env.md @@ -0,0 +1,56 @@ +# Connect to the Development Environment + +## Introduction + +In this lab, you'll learn how to access the web-based JupyterLab development environment, where you can write and run Python code directly in your browser. You'll log in, and get ready to start coding in a hands-on environment. + +Estimated Time: 5 minutes + +### Objectives + +* Login to JupyterLab server +* Run Jupyter Notebook + +## Task 1: Login to JupyterLab Server and open the correct notebook + +Estimated Time: 2 minutes + +1. To navigate to the development environment, click **View Login Info**. Copy the Development IDE Login Password. 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**. + + ![JupyterLab server login](./images/jupyter-login.png " ") + +1. Select **`notebooks/agent_memory`** directory to open it. Double click on one of two files **`notebook_student_oci.ipynb`**, and **`notebook_student_ollama.ipynb`** depending on what the instructor tells you, and that file will open in the the panel on the right. + + ![Open Launcher](./images/launcher.png " ") + +## Task 2: Learn to utilize Agent Memory in your AI apps + +You will use a Jupyter Notebook in a JupyterLab server to build and test database queries. If you are new to notebooks, the following tips will help you get started and work smoothly. + +Estimated Time: 35-45 minutes + +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. + +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! + +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. + +4. **Output & Warnings**: Below each code cell, output appears during and 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. + + **NOTE:** Look for **green text** as in the image below where it says "Connected successfully!". Many cells will have different message, but the final successful one should always be green. When you see the green text, the cell completed. For some longer running cells, this is important to watch for. + + ![JupyterLab cell example](./images/block.png " ") + +## Conclusion + +In this lab you logged into the **IDE Development Environment** for Jupyter Labs. You launched the **`notebook_student_*.ipynb`** notebook and worked through the notebook to learn about using Agent Memory with your AI application development. + +Make sure you take the quiz by clicking on **Take the quiz!** link on the left nav bar. + +## Acknowledgements +* **Authors** - Kirk Kirkconnell +* **Last Updated By/Date** - Kirk Kirkconnell, June 2026 diff --git a/dev-rel-agent-memory/connect-to-env/images/block.png b/dev-rel-agent-memory/connect-to-env/images/block.png new file mode 100644 index 000000000..02ad04838 Binary files /dev/null and b/dev-rel-agent-memory/connect-to-env/images/block.png differ diff --git a/dev-rel-agent-memory/connect-to-env/images/dev-env.png b/dev-rel-agent-memory/connect-to-env/images/dev-env.png new file mode 100644 index 000000000..e63e81594 Binary files /dev/null and b/dev-rel-agent-memory/connect-to-env/images/dev-env.png differ diff --git a/dev-rel-agent-memory/connect-to-env/images/jupyter-login.png b/dev-rel-agent-memory/connect-to-env/images/jupyter-login.png new file mode 100644 index 000000000..c3ba1fde6 Binary files /dev/null and b/dev-rel-agent-memory/connect-to-env/images/jupyter-login.png differ diff --git a/dev-rel-agent-memory/connect-to-env/images/launcher.png b/dev-rel-agent-memory/connect-to-env/images/launcher.png new file mode 100644 index 000000000..84badbe7f Binary files /dev/null and b/dev-rel-agent-memory/connect-to-env/images/launcher.png differ diff --git a/dev-rel-agent-memory/introduction/introduction.md b/dev-rel-agent-memory/introduction/introduction.md new file mode 100644 index 000000000..e7b2d9f63 --- /dev/null +++ b/dev-rel-agent-memory/introduction/introduction.md @@ -0,0 +1,73 @@ +# Introduction + +## About this Workshop + +In this lab, we'll interact with a data set from an application named Prism CityOps, but we will add new database objects combined with the oracleagentmemory Python driver to enable our AI agent to have a memory lifecycle. Prism CityOps is an application used by the city of Kirkland to monitor and manage city infrastrucuter such as ongoing maintenance, active monitoring via IoT devices, crew dispatch, record keeping, and more. This new capability you'll build will help with more in-depth reporting, more informed alerting, and much more. + +You'll utilize a Jupyter Notebook with real Python code, completing real activities, to build this agent with fully fleshed out agents. + +Estimated Workshop Time: 45 - 55 minutes + +✅ **Overview of Labs** + +This notebook builds a field-assistant copilot for city infrastructure inspectors using Oracle AI Database, Ollama, and the oracleagentmemory SDK. Learners see how inspection narratives become durable memory that can help future inspectors reason from prior work instead of starting from scratch. + +* **The data and memory layer** +This section introduces the difference between domain data and agent memory. Learners see how CITY_ASSET and CITY_INSPECTION_FINDING act as the system of record, while SDK-managed tables such as CITY_MESSAGE and CITY_MEMORY capture conversations and extracted facts, preferences, guidelines, and memories. + +* **Design** +This section explains the copilot’s read-then-write cycle: gather context, ask the LLM, persist the turn, and let the SDK derive reusable memory. Learners understand how asset records, context cards, vector search, and automatic memory extraction combine into a single copilot workflow. + +* **Part 1: Oracle setup** +This section connects the notebook to Oracle AI Database and establishes the shared database connection used throughout the workshop. Learners confirm that the SDK tables, custom domain tables, and vector-search operations all live in the same converged database environment. + +* **Part 2: The embedder and SDK** +This section wires Oracle’s in-database ONNX embedding model into the SDK through an embedder adapter. Learners initialize OracleAgentMemory with Ollama for local extraction and see how text becomes database-computed vectors without external embedding calls. + +* **Part 3: City asset + auto-extraction** +This section loads the city asset registry and demonstrates how raw maintenance narratives become typed memory records. Learners build report_event, trigger SDK extraction with add_messages, and verify that messages and extracted memories were persisted. + +* **Part 4: Inspection findings + similar-finding search** +This section creates a structured inspection-finding workflow separate from SDK memory. Learners build log_finding and find_similar_findings, then use Oracle vector search with relational filters to retrieve prior findings by asset, category, and semantic similarity. + +* **Part 5: Scoping - inspector vs city** +This section demonstrates how memory visibility is controlled by user_id, agent_id, and thread_id. Learners verify that one inspector’s private notes do not leak to another inspector, while shared city or asset-level knowledge remains available when intentionally scoped that way. + +* **Part 6: The cityops copilot - End-to-end** +This section assembles the earlier components into call_copilot, the full copilot turn. Learners combine asset lookup, thread context, asset-pooled memory, similar-finding search, LLM reasoning, and write-back into one working assistant flow. + +* **The cross-inspector handoff scenario** +This section shows how Inspector Mercer’s Harbor Bridge findings help Inspector Vance later, without a direct human handoff. Learners see the difference between diagnostic copilot interaction, formal finding capture, and reusable memory that carries forward across inspectors. + +* **Compare: Vance with and without memory** +This section contrasts the same inspection narrative with and without memory-backed context. Learners see why memory changes the quality of the copilot’s answer by surfacing prior findings, guidelines, and asset-specific history. + +* **Key takeaways and memory types** +The closing sections summarize the layers learners built and map SDK record types to broader agent-memory concepts. Learners connect concrete database tables and SDK features to semantic memory, episodic memory, working context, persona preferences, and shared coordination memory. + +### Objectives + +* Connect to Oracle AI Database and initialize the shared database environment used by the copilot. +* Configure an Oracle in-database ONNX embedder and initialize the oracleagentmemory SDK with a local Ollama model. +* Load city infrastructure assets and use SDK auto-extraction to turn inspection narratives into typed memory records. +* Create and query structured inspection findings with Oracle vector search and relational filters. +* Explain how memory scoping prevents private inspector notes from leaking while still supporting shared city or asset-level knowledge. +* Build an end-to-end call_copilot workflow that combines asset lookup, context cards, memory search, similar-finding search, LLM reasoning, and persistence. +* Demonstrate how one inspector’s prior work can improve another inspector’s later diagnosis without exposing raw private conversations. +* Compare copilot responses with and without memory to evaluate the practical value of agent memory in an operational workflow. + +### Prerequisites + +This lab assumes you have: + +* An Oracle account to submit your LiveLabs Sandbox reservation. +* Basic knowledge of coding and Python. +* Basic knowledge of Oracle Database, i.e., how to run queries. + +## Learn More + +* [Oracle AI Database Documentation](https://docs.oracle.com/en/database/oracle/oracle-database/26/) + +## Acknowledgements +* **Authors** - Kirk Kirkconnell +* **Last Updated By/Date** - Kirk Kirkconnell, June 2026 diff --git a/dev-rel-agent-memory/quiz/images/badge.png b/dev-rel-agent-memory/quiz/images/badge.png new file mode 100644 index 000000000..b7d752677 Binary files /dev/null and b/dev-rel-agent-memory/quiz/images/badge.png differ diff --git a/dev-rel-agent-memory/quiz/quiz.md b/dev-rel-agent-memory/quiz/quiz.md new file mode 100644 index 000000000..1c1fde096 --- /dev/null +++ b/dev-rel-agent-memory/quiz/quiz.md @@ -0,0 +1,82 @@ +# Quiz + +## Introduction + +Test your knowledge of building with agent memory! This quiz covers key concepts from the presentation and lab including types of agent memory, what each type is best for, and how to use them effectively. + +Estimated Time: 5 minutes + +```quiz-config + passing: 80 + badge: images/badge.png +``` + +### Objectives + +* To pass the quize and get your **Zero to Hero: Agent Memory** Skills Badge! + +### Quiz Questions + +```quiz score + +Q: What are the three types of long-term memory in Agent Memory? +- Entity, conversational, and persona memory +* Procedural, episodic, and semantic memory +- Volatile, inconsistent, and passive-aggressive memory +- Goldfish mode, 'What did I come in here for?' mode, and 'I'll remember this later, I promise' memory +> Procedural, episodic, and semantic memories branch out to the Execution, Experiece, and Knowledge layers respectively to enable your application to store and utilize all kinds of data long-term. + +Q: What is the difference between domain data and memory in the lab? +- Domain data is created by Ollama, while memory is loaded from JSON files +- Domain data is private to each inspector, while memory is always public +- Domain data stores prompts, while memory stores only embeddings +* Domain data is the system of record, while memory is what the agent accumulates from interactions +> `CITY_ASSET` and `CITY_INSPECTION_FINDING` hold structured operational data, while SDK-managed memory tables store conversations and extracted facts, preferences, guidelines, and memories. + +Q: Why does the notebook use an in-database ONNX embedding model? +- To fine-tune Ollama on inspection findings +- To convert SQL tables into Markdown summaries +* To compute vector embeddings inside Oracle without sending text to an external embedding service +- To disable vector search during the lab +> The embedder adapter exposes Oracle’s in-database embedding capability to the SDK, keeping embedding generation close to the data, but as with anything there are trade-offs. + +Q: What happens when `thread.add_messages(...)` runs with memory extraction enabled? +- The SDK drops and recreates all `CITY_` tables +* The SDK stores the message and uses an extractor LLM to create typed memory records +- The LLM directly inserts rows into `CITY_ASSET` +- The notebook bypasses the database and stores memory only in Python +> `add_messages` writes conversational history and triggers SDK extraction into records such as facts, preferences, guidelines, and memories. + +Q: Why are inspection findings stored in `CITY_INSPECTION_FINDING` instead of only in SDK memory? +* Findings are structured domain records with fields like category, severity, recommendation, grade, and embedding +- SDK memory cannot store any text +- Findings must be visible to every database user without filtering +- Findings are temporary and should disappear after each notebook run +> Inspection findings are part of the formal system of record, so the lab stores them in a dedicated SQL table with a vector column for semantic search. + +Q: What does `find_similar_findings` demonstrate? +- Vector search requires exporting all findings to a separate service +- Similarity search only works if the inspector names match exactly +- The LLM must manually rank all findings +* Oracle can combine vector similarity with relational filters in one SQL query +> The function searches semantically similar findings while also filtering by fields such as asset and category. + +Q: What does the scoping section teach about inspector memory? +- Every inspector can read every raw conversation by default +* Private inspector notes are isolated by scope, while intentionally shared city or asset knowledge can still be retrieved +- Scoping happens only in the notebook UI +- Memory records are scoped by file path instead of database fields +> The lab uses `user_id`, `agent_id`, and `thread_id` as SQL-backed scope controls to prevent unintended cross-inspector leakage. + +Q: In the cross-inspector handoff scenario, how does Vance benefit from Mercer’s earlier work? +- Vance receives Mercer's entire message history by default +- Mercer manually forwards her notebook output to Vance +- The LLM guesses what Mercer probably observed +* The copilot retrieves Mercer's logged findings and extracted asset-level memory without exposing her raw private conversation +> The handoff works because structured findings and asset-pooled extracted memories are retrievable for the same asset while private thread history remains scoped. + +``` + +## Acknowledgements +* **Authors** - Kirk Kirkconnell +* **Last Updated By/Date** - Kirk Kirkconnell, January 2026 diff --git a/dev-rel-agent-memory/workshops/sandbox/index.html b/dev-rel-agent-memory/workshops/sandbox/index.html new file mode 100644 index 000000000..aebbdda4a --- /dev/null +++ b/dev-rel-agent-memory/workshops/sandbox/index.html @@ -0,0 +1,63 @@ + + + + + + + + + Oracle LiveLabs + + + + + + + + + + + + + +
+
+
+
+
+
+
+
+ + + + + diff --git a/dev-rel-agent-memory/workshops/sandbox/manifest.json b/dev-rel-agent-memory/workshops/sandbox/manifest.json new file mode 100644 index 000000000..01defc4b9 --- /dev/null +++ b/dev-rel-agent-memory/workshops/sandbox/manifest.json @@ -0,0 +1,26 @@ +{ + "workshoptitle": "From Zero to Hero: Agent Memory", + "help": "livelabs-help-database_us@oracle.com", + "tutorials": [ + { + "title": "Introduction", + "description": "The Introduction is always first. The title and contents menu title match for the Introduction.", + "filename": "../../introduction/introduction.md" + }, + { + "title": "Connect to the Development Environment", + "description": "This is a step-by-step guide showcasing how the hands-on lab instance is navigated", + "filename": "../../connect-to-env/connect-to-env.md" + }, + { + "title": "Take the quiz!", + "description": "You can take the quiz and get a Skills Badge!", + "filename": "../../quiz/quiz.md" + }, + { + "title": "Need Help?", + "description": "Solutions to Common Problems and Directions for Receiving Live Help", + "filename": "https://livelabs.oracle.com/cdn/common/labs/need-help/need-help-freetier.md" + } + ] +} \ No newline at end of file diff --git a/dev-rel-rag-to-agents/connect-to-env/connect-to-env.md b/dev-rel-rag-to-agents/connect-to-env/connect-to-env.md new file mode 100644 index 000000000..3ff1ad735 --- /dev/null +++ b/dev-rel-rag-to-agents/connect-to-env/connect-to-env.md @@ -0,0 +1,53 @@ +# Connect to the Development Environment + +## Introduction + +In this lab, you'll learn how to access the web-based JupyterLab development environment, where you can write and run Python code directly in your browser. You'll log in, and get ready to start coding in a hands-on environment. + +Estimated Time: 5 minutes + +### Objectives + +* Login to JupyterLab server +* Run Jupyter Notebook + +## Task 1: Login to JupyterLab Server + +1. To navigate to the development environment, click **View Login Info**. Copy the Development IDE Login Password. 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**. + + ![Login](./images/jupyter-login.png " ") + +1. Select **`notebooks/rag_to_agents`** directory to open it. Double click on file **`rag_to_agents_lab.ipynb`** and it will open in the the panel on the right. + + ![Open Launcher](./images/launcher.png " ") + +## Task 2: Learn to use RAG and AI agents in a production app + +You will use a Jupyter Notebook in a JupyterLab server to build and test database queries. If you are new to notebooks, the following tips will help you get started and work smoothly. + +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. + +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! + +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. + +4. **Output & Warnings**: Below each code cell, output appears during and 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. + + **NOTE:** Look for **green text** as in the image below where it says "Connected successfully!". Many cells will have different message, but the final successful one should always be green. When you see the green text, the cell completed. For some longer running cells, this is important to watch for. + + ![JupyterLab blocks](./images/block.png " ") + +## Conclusion + +In this lab you logged into the **IDE Development Environment** for Jupyter Labs. You launched the **`rag_to_agents_lab.ipynb`** notebook and worked through the notebook to learn about RAG and AI agent production applications. + +Make sure you take the quiz by clicking on **Take the quiz!** link on the left nav bar. + +## Acknowledgements +* **Authors** - Kirk Kirkconnell +* **Contributors** - Anant Srivastava +* **Last Updated By/Date** - Kirk Kirkconnell, June 2026 diff --git a/dev-rel-rag-to-agents/connect-to-env/images/block.png b/dev-rel-rag-to-agents/connect-to-env/images/block.png new file mode 100644 index 000000000..02ad04838 Binary files /dev/null and b/dev-rel-rag-to-agents/connect-to-env/images/block.png differ diff --git a/dev-rel-rag-to-agents/connect-to-env/images/dev-env.png b/dev-rel-rag-to-agents/connect-to-env/images/dev-env.png new file mode 100644 index 000000000..e63e81594 Binary files /dev/null and b/dev-rel-rag-to-agents/connect-to-env/images/dev-env.png differ diff --git a/dev-rel-rag-to-agents/connect-to-env/images/jupyter-login.png b/dev-rel-rag-to-agents/connect-to-env/images/jupyter-login.png new file mode 100644 index 000000000..c3ba1fde6 Binary files /dev/null and b/dev-rel-rag-to-agents/connect-to-env/images/jupyter-login.png differ diff --git a/dev-rel-rag-to-agents/connect-to-env/images/launcher.png b/dev-rel-rag-to-agents/connect-to-env/images/launcher.png new file mode 100644 index 000000000..84badbe7f Binary files /dev/null and b/dev-rel-rag-to-agents/connect-to-env/images/launcher.png differ diff --git a/dev-rel-rag-to-agents/introduction/introduction.md b/dev-rel-rag-to-agents/introduction/introduction.md new file mode 100644 index 000000000..ae1f9e675 --- /dev/null +++ b/dev-rel-rag-to-agents/introduction/introduction.md @@ -0,0 +1,58 @@ +# Introduction + +## About this Workshop + +In this lab, we'll interact with a data set from an application named Prism CityOps. It's an application used by the city of Kirkland to monitor and manage city infrastrucuter such as ongoing maintenance, active monitoring via IoT devices, crew dispatch, record keeping, and more. + +You'll utilize a Jupyter Notebook with real Python code, completing real activities, and building on what you already know about databases and AI Vector Search. You'll create a RAG pipeline using data in the database and work your way up to implementing a full on AI agent, with tools and a little memory, utilizing LangChain as the agent framework. + +Estimated Workshop Time: 50 - 60 minutes + +✅ **Overview of Labs** + +In the next labs, you'll connect to your JupyterLab environment and work through the RAG to Agent notebook built around the Prism CityOps dataset. You'll use the same operational data you did with the Data Fundamentals lab, but this time you'll build real workflows with the data. + +* **Lab 1 – Connect to your environment and confirm database is ready** +Log in to the JupyterLab IDE where you’ll run Python code and run the section 0 cells to confirm the database is ready for the lab. + +* **Lab 2 – RAG, grounded in your own data** +This section builds a minimal Retrieval-Augmented Generation path over Prism maintenance and inspection content using Oracle’s in-database ONNX embedding model and vector search. Learners inspect retrieved chunks, assemble grounded prompts, compare a raw Ollama-based RAG call with a LangChain version, and see why RAG is powerful for grounded answers but insufficient for multi-step operational reasoning. + +* **Lab 3 – Tools and skills** +This section introduces the concepts the agent will need before it is built: callable tools and SOP-like skills. Learners define allowlisted Prism data tools, learn why tool signatures and docstrings matter to the model-facing interface, and create an incident-triage skill that tells the future agent which tools to use, in what order, and under what evidence standards. + +* **Lab 4 – The unified query** +This section demonstrates the core Oracle AI Database value proposition by combining relational data, JSON specifications, SQL/PGQ graph traversal, and vector search in a single SQL-backed incident brief. Learners run the unified query, inspect the combined result, and wrap it as the agent’s primary context tool so the agent can retrieve rich operational evidence through one controlled interface. + +* **Lab 4 – Build the agent with LangGraph + Ollama** +This section assembles the full agent: a LangGraph reasoning loop backed by Ollama, allowlisted tools, an incident-triage skill, Oracle-backed short-term checkpoint memory, and Oracle-backed long-term semantic memory. Learners reset rerun state, compile the graph, run the first agent turn, inspect tool calls and trace output, and verify that durable memory was written back to the database. + +By the end, you'll understand how Oracle AI Database supports AI application development use LangChain, LLMs, AI Agents, and your own data pipelines. + +### Objectives + +* Build a grounded RAG flow that retrieves Prism maintenance context using in-database embeddings and vector search, then uses that context to answer asset-related questions. + +* Compare raw RAG plumbing with a LangChain-based implementation to understand what the framework simplifies and what remains the developer’s responsibility. + +* Run a deterministic LLM-driven workflow that classifies an infrastructure incident, retrieves supporting context, drafts a recommendation, formats the result, and exposes trace data for review. + +* Define agent tools and a task-specific skill that guide how an LLM should retrieve asset context, follow evidence rules, and produce incident-triage recommendations. + +* Build and run a LangGraph agent that uses Oracle-backed tools, unified relational/JSON/graph/vector context, short-term checkpoint memory, and long-term semantic memory to respond to a Prism infrastructure incident. + +### Prerequisites + +This lab assumes you have: + +* An Oracle account to submit your LiveLabs Sandbox reservation. +* Basic knowledge of coding and Python. +* Basic knowledge of Oracle Database, i.e., how to run queries. + +## Learn More + +* [Oracle AI Database Documentation](https://docs.oracle.com/en/database/oracle/oracle-database/26/) + +## Acknowledgements +* **Authors** - Kirk Kirkconnell +* **Last Updated By/Date** - Kirk Kirkconnell, June 2026 diff --git a/dev-rel-rag-to-agents/quiz/images/badge.png b/dev-rel-rag-to-agents/quiz/images/badge.png new file mode 100644 index 000000000..b7d752677 Binary files /dev/null and b/dev-rel-rag-to-agents/quiz/images/badge.png differ diff --git a/dev-rel-rag-to-agents/quiz/quiz.md b/dev-rel-rag-to-agents/quiz/quiz.md new file mode 100644 index 000000000..b7ce8798e --- /dev/null +++ b/dev-rel-rag-to-agents/quiz/quiz.md @@ -0,0 +1,74 @@ +# Quiz + +## Introduction + +Test your knowledge of building a RAG and agentic! This quiz covers key concepts from the lab including Vector Search, embeddings, Python integration, and AI-powered recommendation systems. + +Estimated Time: 5 minutes + +```quiz-config + passing: 80 + badge: images/badge.png +``` + +### Objectives + +* Pass the quiz and get your "Zero to Hero: RAG to Agents" skills badge! + +### Quiz Questions + +```quiz score +Q: What is the main purpose of the RAG retriever in Section 1? +* To retrieve semantically relevant Prism chunks using in-database vector embeddings and vector distance +- To let the LLM choose arbitrary database tables to query +- To store long-term memories for later conversations +- To format the final incident report as markdown +> The retriever grounds the model by selecting relevant database-backed context before the LLM generates an answer. + +Q: What does the raw RAG implementation demonstrate before the LangChain version is introduced? +- RAG requires an agent framework to work +- RAG automatically performs multi-step planning +- RAG removes the need to inspect retrieved context +* RAG is mainly retrieval, prompt assembly, and an LLM call +> The raw version makes the moving parts visible, which helps learners understand what a framework simplifies later. + +Q: What is the key tradeoff of a LLM-driven workflow? +* It is predictable and auditable, but less adaptive than an agent +- It is fully autonomous, but impossible to trace +- It avoids prompts entirely, but requires manual SQL every time +- It replaces retrieval quality with model memory +> The workflow follows a fixed path with bounded LLM calls, which improves control but limits flexibility when the problem changes. + +Q: Why do tool signatures and docstrings matter? +- They change the physical database schema used by the tool +* They define the model-facing interface that helps the LLM decide when and how to call a tool +- They automatically validate every SQL result returned by Oracle +- They prevent the framework from executing tool calls +> The LLM sees the tool name, inputs, and description, so clear interfaces improve tool selection and usage. + +Q: What makes the unified query important? +- It moves data into a separate vector database for faster retrieval +- It asks the LLM to generate SQL without constraints +- It replaces the need for asset metadata +* It combines relational, JSON, graph, and vector evidence in one Oracle-backed SQL call +> The unified query shows how Oracle AI Database can provide rich incident context without, CDC, synchronization, ETL, or separate data stores. + +Q: What role does LangGraph play in the lab? +- It creates the original PRISM seed data +- It replaces Ollama as the LLM runtime +* It implements the agent reasoning loop where the model can answer or request allowed tool calls +- It converts markdown quiz blocks into notebook cells +> LangGraph provides the state graph, tool loop, checkpointing, and memory wiring used by the agent. + +Q: Why does the notebook use both short-term and long-term memory for the agent? +* Short-term memory preserves the current thread, while long-term memory stores durable recallable knowledge across runs +- Short-term memory stores SQL tables, while long-term memory stores only Python variables +- Short-term memory replaces retrieval, while long-term memory disables tool calls +- Both memories are temporary and disappear when the notebook kernel stops +> The notebook separates conversation state from persistent semantic memory so the agent can continue a thread and recall prior incident decisions. + +``` + +## Acknowledgements +* **Authors** - Kirk Kirkconnell +* **Last Updated By/Date** - Kirk Kirkconnell, January 2026 diff --git a/dev-rel-rag-to-agents/workshops/sandbox/index.html b/dev-rel-rag-to-agents/workshops/sandbox/index.html new file mode 100644 index 000000000..aebbdda4a --- /dev/null +++ b/dev-rel-rag-to-agents/workshops/sandbox/index.html @@ -0,0 +1,63 @@ + + + + + + + + + Oracle LiveLabs + + + + + + + + + + + + + +
+
+
+
+
+
+
+
+ + + + + diff --git a/dev-rel-rag-to-agents/workshops/sandbox/manifest.json b/dev-rel-rag-to-agents/workshops/sandbox/manifest.json new file mode 100644 index 000000000..740c9df18 --- /dev/null +++ b/dev-rel-rag-to-agents/workshops/sandbox/manifest.json @@ -0,0 +1,26 @@ +{ + "workshoptitle": "From Zero to Hero: RAG to Agents", + "help": "livelabs-help-database_us@oracle.com", + "tutorials": [ + { + "title": "Introduction", + "description": "The Introduction is always first. The title and contents menu title match for the introduction.", + "filename": "../../introduction/introduction.md" + }, + { + "title": "Connect to the Development Environment", + "description": "This is a step-by-step guide showcasing how the hands-on lab instance is navigated", + "filename": "../../connect-to-env/connect-to-env.md" + }, + { + "title": "Take the quiz!", + "description": "A quiz cover this lab you take to get your Skills Badge.", + "filename": "../../quiz/quiz.md" + }, + { + "title": "Need Help?", + "description": "Solutions to common problems with LiveLabs and directions for receiving live help", + "filename": "https://livelabs.oracle.com/cdn/common/labs/need-help/need-help-freetier.md" + } + ] +} \ No newline at end of file