Overview
Domain 3 turns vector search into a complete retrieval-augmented generation pipeline inside Oracle AI Database. The steps are: extract text from source documents, split it into chunks, embed the chunks, store and index them, retrieve the closest chunks for a question, and pass them to a large language model as grounding context. Oracle covers each step with PL/SQL.
DBMS_VECTOR_CHAIN supplies UTL_TO_TEXT, UTL_TO_CHUNKS, UTL_TO_EMBEDDINGS, UTL_TO_SUMMARY and UTL_TO_GENERATE_TEXT, and DBMS_VECTOR handles credentials and single-call helpers. You should know chunking parameters such as size, overlap and split strategy, how vectorizer preferences automate the pipeline, and how Select AI with RAG wraps the same idea in a profile-backed vector index. Prompt construction, provider credentials and network access lists round out the section.
How it's tested
Questions follow the pipeline. You might see four PL/SQL calls out of order and pick the right sequence, or read a symptom such as answers missing key facts and choose the chunking change that fixes it. Provider questions focus on credentials, model parameters and where generation happens.
-
Order the pipeline
Extraction, chunking, embedding, indexing, retrieval and generation are listed, and you choose the correct order or the missing step.
-
Fix the chunking
A symptom about missing context or noisy answers leads to changing chunk size, overlap, or split method in UTL_TO_CHUNKS.
-
Pick the package call
A task such as converting a PDF or calling an LLM maps to the right DBMS_VECTOR_CHAIN or DBMS_VECTOR subprogram.
Answers from a policy chatbot sometimes stop halfway through a rule. The documents are split into 200-word chunks with no overlap, so rules that cross a chunk boundary are cut. Raising the overlap parameter in UTL_TO_CHUNKS, or splitting by sentence or paragraph, keeps each rule together. Changing the LLM would not help because retrieval is handing it incomplete text.
Topics 4
Official topics from the Oracle outline, in outline order.
3.1 Describe the RAG workflow in Oracle AI DatabaseRetrieval, augmentation and generation steps and why they reduce hallucination.
- What it means
- RAG answers a question by first retrieving relevant content from your own data through vector search, then adding that content to the prompt sent to a large language model. The model generates its answer grounded in the retrieved text rather than relying only on what it learned in training.
- What to understand
- Grounding reduces hallucination and keeps answers current without fine-tuning. Running retrieval in the database means security rules, row filters and joins apply to what the model sees. Answer quality depends on both stages: weak retrieval gives the model the wrong context, and a weak prompt lets it ignore good context.
- How it shows up
- You may be asked why RAG beats fine-tuning for frequently changing documents, or which stage caused a bad answer.
- Common confusion
- Believing RAG retrains the model; it only supplies context at question time.
3.2 Prepare documents with DBMS_VECTOR_CHAINUTL_TO_TEXT, UTL_TO_CHUNKS and chunking parameters.
- What it means
- UTL_TO_TEXT extracts plain text from formats such as PDF, Word or HTML stored in BLOB columns. UTL_TO_CHUNKS splits that text using parameters for maximum size, overlap, split method (characters, words, sentences, newlines or recursive) and normalization. The VECTOR_CHUNKS SQL operator offers the same chunking inside a query.
- What to understand
- Chunk size must fit the embedding model's input limit and be small enough to stay on one topic. Overlap repeats a little text across neighbouring chunks so ideas that cross a boundary survive. Keeping document id and chunk offset alongside each chunk lets you cite sources and group results by document later.
- How it shows up
- Expect a symptom of truncated or noisy answers and a choice of chunking parameter to change.
- Common confusion
- Running UTL_TO_CHUNKS on raw PDF binaries; text must be extracted with UTL_TO_TEXT first.
3.3 Generate, store and retrieve chunk embeddingsUTL_TO_EMBEDDINGS, vectorizers and similarity retrieval.
- What it means
- UTL_TO_EMBEDDINGS embeds a set of chunks in one call, either with an in-database ONNX model or an external provider. Results are stored in a VECTOR column with the chunk text and metadata, indexed, and then queried with VECTOR_DISTANCE to find the top-k chunks for a question. Vectorizer preferences in DBMS_VECTOR_CHAIN can automate this for a table.
- What to understand
- The question must be embedded with the same model as the chunks. Retrieval usually returns a handful of chunks, enough for context without overflowing the LLM's window. Partitioned retrieval can limit how many chunks one document contributes, which keeps answers balanced across sources.
- How it shows up
- A question may show a pipeline that embeds chunks one way and queries another way and ask what is wrong.
- Common confusion
- Embedding whole documents rather than chunks, which blurs topics and weakens retrieval.
3.4 Generate grounded responses with LLM providersUTL_TO_GENERATE_TEXT, credentials, prompts and Select AI RAG.
- What it means
- DBMS_VECTOR_CHAIN.UTL_TO_GENERATE_TEXT and UTL_TO_SUMMARY call a configured LLM, such as OCI Generative AI or a local Ollama model, after a credential is created with CREATE_CREDENTIAL. Select AI offers a higher-level route: a profile with a vector index created by DBMS_CLOUD_AI.CREATE_VECTOR_INDEX and SELECT AI NARRATE answering from retrieved content.
- What to understand
- The prompt should combine an instruction, the retrieved chunks and the user question, and tell the model to answer only from the context. On databases outside Autonomous AI Database, outbound calls also need network access control entries. Provider parameters such as model name and maximum tokens are passed as JSON.
- How it shows up
- Scenarios ask which package call produces the final answer, or what setup is missing when the call fails with an authorization error.
- Common confusion
- Thinking UTL_TO_GENERATE_TEXT retrieves documents; it only sends a prompt to the model.
High-yield concepts
The terms, rules and formulas this domain turns into questions most often.
-
Retrieval-augmented generation
Retrieve relevant private content, then ask the LLM to answer using it.
- Remember
- No retraining is involved.
- Tested as
- Architecture and why-RAG questions.
- Trap
- Confusing RAG with fine-tuning.
-
UTL_TO_TEXT
Extracts plain text from documents such as PDF or DOCX.
- Remember
- Comes before chunking.
- Tested as
- Pipeline order questions.
- Trap
- Chunking binary content directly.
-
UTL_TO_CHUNKS
Splits text into chunks by size, overlap and method.
- Remember
- Overlap preserves boundary context.
- Tested as
- Chunk tuning scenarios.
- Trap
- Setting overlap to zero by default.
-
VECTOR_CHUNKS
SQL operator that chunks text inside a query.
- Remember
- Same chunking logic usable in SELECT.
- Tested as
- SQL-centric pipelines.
- Trap
- Assuming chunking needs PL/SQL only.
-
UTL_TO_EMBEDDINGS
Embeds many chunks in one call.
- Remember
- Uses an ONNX model or a provider.
- Tested as
- Embedding step questions.
- Trap
- Embedding whole documents.
-
UTL_TO_GENERATE_TEXT
Sends a prompt to a configured LLM and returns text.
- Remember
- Generation only, no retrieval.
- Tested as
- Final-answer step.
- Trap
- Expecting it to search vectors.
-
UTL_TO_SUMMARY
Summarises a document or chunk with an LLM or Oracle Text.
- Remember
- Useful for long-document context.
- Tested as
- Preprocessing questions.
- Trap
- Confusing it with chunking.
-
CREATE_CREDENTIAL
Stores provider keys for DBMS_VECTOR calls.
- Remember
- Needed before any external provider call.
- Tested as
- Authorization error scenarios.
- Trap
- Hard-coding keys in parameters.
-
Network ACL
Access control entries that allow outbound HTTP.
- Remember
- Required on non-Autonomous databases.
- Tested as
- Failed provider call scenarios.
- Trap
- Blaming the credential when the host is blocked.
-
Select AI with RAG
Profile plus vector index lets SELECT AI NARRATE answer from documents.
- Remember
- Index built with DBMS_CLOUD_AI.CREATE_VECTOR_INDEX.
- Tested as
- High-level RAG questions.
- Trap
- Assuming it needs manual chunking code.
Side by side
Concepts candidates mix up, compared on the point that decides the answer.
DBMS_VECTOR_CHAIN pipeline steps
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| UTL_TO_TEXT | Document to plain text | First step for binary formats | Skipping it for PDFs |
| UTL_TO_CHUNKS | Text to chunks | Controls size, overlap and split method | Chunks too large for the model |
| UTL_TO_EMBEDDINGS | Chunks to vectors | Batch embedding with a chosen model | Different model at query time |
| UTL_TO_GENERATE_TEXT | Prompt to LLM answer | Generation only | Expecting retrieval inside it |
RAG vs. fine-tuning vs. prompt only
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| RAG | Retrieve private context at question time | Current data, citations possible | Ignoring retrieval quality |
| Fine-tuning | Adjust model weights with training data | Changes model behaviour, slow to refresh | Using it for fast-changing documents |
| Prompt only | Ask the model without added context | No private knowledge | Expecting accurate answers about internal data |
Two ways to build RAG
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| DBMS_VECTOR_CHAIN code | Explicit PL/SQL for each step | Full control over chunking and prompts | More code to maintain |
| Select AI with RAG | Profile and vector index managed by DBMS_CLOUD_AI | Less code, natural-language queries | Assuming it works without a vector index |
Exam traps
Each trap is an answer that looks right. Learn the clue that should change your mind.
-
RAG retrains the model
- What candidates pick
- Pick fine-tuning to add new policies weekly.
- Why it looks right
- Training sounds like how models learn.
- Why it's wrong
- RAG supplies fresh context at query time; fine-tuning is slow to repeat and does not cite sources.
Clue to watch for Documents change often or answers must cite sources.
-
Bigger chunks are better
- What candidates pick
- Raise chunk size to fix vague answers.
- Why it looks right
- More text seems like more context.
- Why it's wrong
- Large chunks mix topics and weaken similarity scores; smaller focused chunks with some overlap usually retrieve better.
Clue to watch for Answers are on topic but imprecise.
-
Generation call retrieves
- What candidates pick
- Expect UTL_TO_GENERATE_TEXT to search the vector table.
- Why it looks right
- It is part of the vector chain package.
- Why it's wrong
- UTL_TO_GENERATE_TEXT only sends a prompt; retrieval is a separate similarity query.
Clue to watch for The pipeline has no VECTOR_DISTANCE step.
-
Credential fixes all call failures
- What candidates pick
- Recreate the credential when an on-premises call to a provider times out.
- Why it looks right
- Authentication errors are common.
- Why it's wrong
- On databases outside Autonomous AI Database, outbound hosts must also be allowed through network access control entries.
Clue to watch for A connection or host error rather than an authorization error.
-
Whole-document embedding
- What candidates pick
- Embed each full document as one vector.
- Why it looks right
- Fewer vectors seem simpler.
- Why it's wrong
- One vector per document averages many topics, so specific questions match poorly; chunk-level vectors fix this.
Clue to watch for Long documents with many sections.
Answer framework
Trace a RAG scenario through the pipeline in this order to find the failing step.
- Confirm source documents are converted to text with UTL_TO_TEXT before any chunking happens, so PDFs, Word files and HTML become plain text that the chunker can split.
- Check chunk size, overlap and split method in UTL_TO_CHUNKS against the content's structure and the model's input limit; too small a chunk cuts procedures in half, while modest overlap keeps neighbouring sentences together.
- Verify that chunks and questions are embedded with one model and stored in an indexed VECTOR column, such as an HNSW or IVF index whose distance metric matches the model.
- Inspect retrieval: top-k size, metric, filters and per-document limits decide what context reaches the model.
- Check generation last: credential, network access, provider parameters and a prompt that tells the model to use the context.
Practice question
Want more like this? The 1Z0-1159-26 practice test has questions for every domain.
Checklist
0 of 12
Tick each one you can do without notes. Your ticks stay in this browser.
Study strategy
Build one small RAG pipeline end to end; nothing prepares you better for the ordering and troubleshooting questions. Load five or six PDFs into a BLOB column, convert them with UTL_TO_TEXT, chunk them with UTL_TO_CHUNKS, embed with UTL_TO_EMBEDDINGS and store the results with document ids.
Write a retrieval query that returns the top five chunks for a question, then paste those chunks into a prompt and call UTL_TO_GENERATE_TEXT. Change chunk size and overlap and watch how answers change; that experiment covers most chunking questions. Deliberately remove the credential, and on a non-Autonomous database the network ACL, so you recognise each error.
Next, repeat the task with Select AI with RAG on Autonomous AI Database: create a vector index with DBMS_CLOUD_AI.CREATE_VECTOR_INDEX, attach it to a profile and ask questions with SELECT AI NARRATE. Compare the effort with the hand-built version. Finish by writing the six pipeline steps from memory with the package call for each, then attempt timed scenario questions. Mark each miss as a retrieval-side or generation-side error so you know which half of the pipeline to review again.
FAQ
How much of 1Z0-1159-26 is Domain 3, Build Retrieval-Augmented Generation (RAG) Solutions?
Oracle publishes no weights for this exam. Third-party practice material treats this RAG section as one of the larger blocks, so expect a good share of pipeline questions.
What is the correct order of the DBMS_VECTOR_CHAIN steps?
Extract text with UTL_TO_TEXT, chunk with UTL_TO_CHUNKS, embed with UTL_TO_EMBEDDINGS, store and index, retrieve with a similarity query, then generate with UTL_TO_GENERATE_TEXT.
Why use overlap when chunking?
Overlap repeats a little text between neighbouring chunks, so a sentence or rule that crosses a boundary still appears whole in at least one chunk.
Do I need DBMS_VECTOR_CHAIN to use RAG in Autonomous AI Database?
No. Select AI with RAG builds and manages the vector index through DBMS_CLOUD_AI, though the explicit package gives more control.
Why does my provider call fail on an on-premises database?
Outbound HTTP needs a network access control entry for the provider host as well as a valid credential. Autonomous AI Database handles much of that configuration.
Which LLM providers can generate answers?
Oracle documents providers such as OCI Generative AI, Cohere, OpenAI, Google, Hugging Face and local Ollama endpoints, configured through JSON parameters.
Is RAG better than fine-tuning for company policies?
Usually yes. Policies change often and answers should cite sources, which RAG handles at query time without retraining.
Other Artificial Intelligence & Machine Learning certifications
Where the same subject shows up in other exams. Cards marked "Same subject" open the matching domain.
Test your Domain 3 knowledge
You have covered the full RAG chain: text extraction, chunking, embeddings, retrieval, generation and Select AI with RAG. See if you can find the failing step in a scenario.
Keep going
- Training Training Built on your Weak areas
- Practice test Questions by domain, with explanations
- Mock exam Full length, timed like the real exam
- Readiness test Find your weakest domain in minutes
- Cheat sheet Key terms and formulas on one page
- Ask the 1Z0-1159-26 AI tutor Get any concept explained your way