Courseiva

CCNA Building LLM Applications with RAG and Vector Search Questions

69 questions · Building LLM Applications with RAG and Vector Search · All types, answers revealed

Practice these questionsDomain overviewAll questions
1
MCQeasy

A developer is using OCI Generative AI to build a question-answering system over a large corpus of technical manuals. The developer uses the Cohere Embed model to generate embeddings and stores them in an OCI OpenSearch cluster. Queries are slow and the team needs to reduce latency. Which approach is BEST for improving search speed while maintaining acceptable accuracy?

A.Increase the embedding dimension for better representation.
B.Reduce the k value in the nearest neighbor search.
C.Use exact nearest neighbor search instead of approximate.
D.Increase the index refresh interval to reduce write overhead.
AnswerB

Fewer neighbors means less distance computation and faster retrieval.

Why this answer

Reducing the k value in the nearest neighbor search directly decreases the number of vectors that must be compared during query time, which lowers latency. In approximate nearest neighbor (ANN) search, a smaller k means fewer candidates are evaluated, speeding up retrieval while still maintaining acceptable accuracy if the original k was unnecessarily high. This is the most effective tuning knob for latency in vector search systems like OCI OpenSearch with Cohere embeddings.

Exam trap

The trap here is that candidates often confuse reducing k with reducing accuracy, but in practice, many RAG systems use a k value larger than necessary, and reducing it to a reasonable minimum (e.g., from 20 to 5) can dramatically improve speed without noticeable quality loss.

How to eliminate wrong answers

Option A is wrong because increasing the embedding dimension increases the computational cost of distance calculations and memory usage, which would worsen latency, not improve it. Option B is wrong because exact nearest neighbor search (k-NN) requires scanning all vectors, which is O(n) and significantly slower than approximate methods, especially on large corpora. Option D is wrong because increasing the index refresh interval reduces write overhead but does not affect query latency; it only delays the visibility of new documents.

Practice this question →
2
MCQmedium

Which OCI service provides a managed vector database capability that can be used as a knowledge base in a RAG architecture?

A.OCI MySQL HeatWave
B.OCI Database (Autonomous Database)
C.OCI Search with OpenSearch
D.OCI Object Storage
AnswerC

OpenSearch includes the k-NN plugin for vector search, managed by OCI.

Why this answer

OCI Search with OpenSearch provides a managed vector database capability through its k-nearest neighbor (k-NN) plugin, which supports storing and querying vector embeddings. This makes it suitable as a knowledge base in a Retrieval-Augmented Generation (RAG) architecture, where vector similarity search retrieves relevant context for LLM prompts.

Exam trap

Oracle often tests the misconception that any database with vector support (like Autonomous Database) is the primary managed vector service, but the question specifically asks for a 'managed vector database capability' as a knowledge base in RAG, and OCI Search with OpenSearch is the dedicated service designed for this purpose.

How to eliminate wrong answers

Option A is wrong because OCI MySQL HeatWave is a managed MySQL database optimized for online transaction processing (OLTP) and analytics via HeatWave acceleration, but it does not natively support vector storage or vector similarity search required for RAG. Option B is wrong because OCI Database (Autonomous Database) supports AI Vector Search only in newer versions (e.g., 23ai) and is not the primary managed vector database service for RAG; it is a general-purpose relational database with added vector capabilities, not a dedicated vector database service. Option D is wrong because OCI Object Storage is a blob storage service for unstructured data (e.g., documents, images) and lacks any query engine or vector indexing capability; it cannot perform vector similarity searches.

Practice this question →
3
MCQmedium

A developer notices that the RAG system returns irrelevant chunks when the user query contains typos or abbreviations. Which technique would BEST improve retrieval robustness for such queries?

A.Decrease the chunk size to focus on smaller units.
B.Increase the number of retrieved chunks to cover more variations.
C.Use a spell-checker on the retrieved chunks.
D.Implement query rewriting or expansion using a language model before embedding.
AnswerD

Rewriting corrects typos and expands abbreviations, improving embedding quality.

Why this answer

Query rewriting or expansion using a language model (LLM) directly addresses typos and abbreviations by generating a corrected or enriched query before embedding. This improves the semantic alignment between the user's intent and the vector search, ensuring that even noisy input retrieves relevant chunks. Techniques like spelling correction or synonym expansion at query time are far more effective than post-retrieval fixes or parameter tuning.

Exam trap

Oracle often tests the misconception that retrieval robustness can be improved by tuning chunk size or retrieval count, when the real bottleneck is the quality of the query embedding itself.

How to eliminate wrong answers

Option A is wrong because decreasing chunk size does not fix typos or abbreviations; it only changes the granularity of retrieval units, potentially missing context or increasing noise. Option B is wrong because increasing the number of retrieved chunks may include more irrelevant results without correcting the query's semantic mismatch caused by typos or abbreviations. Option C is wrong because applying a spell-checker on retrieved chunks is a post-retrieval fix that cannot recover relevance lost during embedding of a malformed query; the damage is already done at the retrieval stage.

Practice this question →
4
Multi-Selecthard

A team is designing a RAG system for a multilingual knowledge base. Which TWO strategies are appropriate? (Choose two.)

Select 2 answers
A.Store separate vector indices per language
B.Disable vector search for non-English queries
C.Translate all documents to English before indexing
D.Use a different embedding model per language
E.Use a single embedding model trained for multilingual text
AnswersA, E

Separate indices allow language-specific preprocessing and retrieval optimizations.

Why this answer

Storing separate vector indices per language allows the RAG system to optimize retrieval for each language's unique semantic and syntactic characteristics. This avoids cross-language interference and enables the use of language-specific preprocessing, tokenization, and embedding models, which improves retrieval accuracy for multilingual queries.

Exam trap

In Oracle OCI GenAI, a common misconception is that a single multilingual embedding model alone is sufficient for all multilingual RAG scenarios, but the correct answer pair (A and E) highlights that both a unified model and language-specific indices can be appropriate strategies depending on the system's requirements.

Practice this question →
5
MCQeasy

A startup is building a customer support chatbot using RAG with OCI Generative AI. They have a large corpus of FAQ documents stored as PDFs in OCI Object Storage. The developer uses OCI Language to embed the text and stores vectors in OCI OpenSearch. During testing, the chatbot often fails to answer questions because relevant FAQ entries are not retrieved. The team suspects the chunking size is too large, causing loss of specific details. After reducing chunk size, retrieval improves slightly but still misses many answers. What should the team do NEXT?

A.Use a sliding window chunking strategy with overlap
B.Increase the number of retrieved chunks (k)
C.Switch to a different embedding model
D.Manually rephrase the queries
AnswerA

Overlap preserves context across chunk boundaries, improving recall.

Why this answer

A sliding window chunking strategy with overlap ensures that context is preserved across chunk boundaries, preventing the loss of specific details that can occur when a relevant sentence or phrase is split between two chunks. This directly addresses the symptom where reducing chunk size alone still misses answers, as overlapping chunks increase the likelihood that the exact text needed for retrieval appears in at least one chunk.

Exam trap

OCI often tests the misconception that simply reducing chunk size or increasing k is sufficient to fix retrieval failures, when in fact the real issue is the lack of context continuity across chunks—a sliding window with overlap is the standard solution in production RAG systems.

How to eliminate wrong answers

Option B is wrong because increasing the number of retrieved chunks (k) may bring in more noise and does not fix the root cause of missing specific details due to chunk boundary issues; it only widens the net without improving chunk quality. Option C is wrong because switching to a different embedding model would not resolve the problem of information being split across chunks—the embedding model's quality is not the bottleneck here, as the issue is chunking strategy, not semantic representation. Option D is wrong because manually rephrasing queries is a brittle, non-scalable workaround that does not address the underlying retrieval failure caused by chunking; the system should be robust to natural query variations.

Practice this question →
6
MCQeasy

A company uses a RAG pipeline with OCI Data Science and Cohere embeddings. They notice that retrieval recall is low for domain-specific acronyms. What is the best practice to improve this?

A.Reduce the cosine similarity threshold in the vector search.
B.Expand acronyms to their full forms during document preprocessing and indexing.
C.Fine-tune the embedding model with domain-specific acronyms.
D.Increase the chunk size to include more context around acronyms.
AnswerB

Full forms improve semantic matching.

Why this answer

Expanding acronyms to their full forms during document preprocessing and indexing ensures that the embedding model can map the acronym to its semantic meaning, improving retrieval recall for domain-specific terms. Cohere embeddings are trained on general text, so without expansion, acronyms like 'NLP' may not match queries for 'Natural Language Processing' in vector space. This preprocessing step directly addresses the root cause of low recall for acronyms.

Exam trap

Oracle often tests the misconception that fine-tuning the embedding model is the default fix for retrieval issues, when in practice simpler preprocessing techniques like acronym expansion are more efficient and recommended for domain-specific vocabulary gaps.

How to eliminate wrong answers

Option A is wrong because reducing the cosine similarity threshold would increase the number of retrieved chunks but also introduce more irrelevant results, degrading precision without fixing the underlying embedding mismatch for acronyms. Option C is wrong because fine-tuning the embedding model is resource-intensive and typically unnecessary for this issue; preprocessing acronyms is a simpler, more effective solution that avoids retraining. Option D is wrong because increasing chunk size may add more context but does not resolve the core problem that the acronym itself is not semantically represented in the embedding space, so the retrieval still fails to match the intended concept.

Practice this question →
7
MCQhard

An enterprise RAG application experiences high latency during peak hours. The architecture uses OCI OpenSearch with a single node cluster storing 5 million vectors (768 dimensions). The search uses exact k-NN (EF_SEARCH=500). The average query takes 1.5 seconds, but the SLA requires <500ms. The team considers several options: A) Switch to ANN with lower recall (HNSW with ef_search=50), B) Scale OpenSearch cluster to 3 nodes, C) Reduce embedding dimension to 256 using PCA, D) Increase the number of shards from 1 to 10. Which option provides the best balance of latency reduction and minimal impact on retrieval quality? (Assume all options are feasible)

A.Scale OpenSearch cluster to 3 nodes
B.Increase the number of shards from 1 to 10
C.Switch to ANN (HNSW with ef_search=50)
D.Reduce embedding dimension to 256 using PCA
AnswerB

More shards divide the vector set, allowing parallel exact searches on smaller partitions, reducing latency without quality loss.

Why this answer

Increasing shards on the same node partitions the index, so each shard contains fewer vectors, making exact search faster. This reduces latency without sacrificing accuracy. ANN reduces recall, scaling adds cost and complexity, and dimension reduction can degrade embedding quality.

Practice this question →
8
MCQeasy

When invoking the OCI Generative AI service from a RAG application, the developer receives a 401 Unauthorized error. The application uses resource principal authentication from an OCI Data Science notebook session. What is the most likely fix?

A.Add the Generative AI service to the subnet's security list
B.Use an API key instead of resource principal
C.Ensure the dynamic group includes the data science notebook session and has the correct policy
D.Restart the notebook session
AnswerC

The dynamic group must match the session, and the policy must grant access to the Generative AI service.

Why this answer

The 401 Unauthorized error indicates that the OCI Generative AI service cannot authenticate the request. In a RAG application using resource principal authentication from an OCI Data Science notebook session, the notebook session must be a member of a dynamic group, and that dynamic group must have an IAM policy granting it the necessary permissions (e.g., `allow dynamic-group <name> to use generative-ai-family in compartment <name>`). Option C correctly identifies that the dynamic group configuration or policy is missing or incorrect, which is the most likely cause of the authentication failure.

Exam trap

Oracle often tests the distinction between network-level issues (security lists, NACLs) and IAM-level issues (dynamic groups, policies) — the trap here is that candidates may confuse a 401 Unauthorized error with a network connectivity problem and incorrectly choose a security list fix.

How to eliminate wrong answers

Option A is wrong because security lists control network traffic at the subnet level, not authentication; a 401 error is an authentication/authorization issue, not a network connectivity issue. Option B is wrong because using an API key would bypass the resource principal mechanism but is not a 'fix' — it changes the authentication method entirely and may not be desirable or secure for a notebook session; the question asks for the most likely fix given the existing resource principal setup. Option D is wrong because restarting the notebook session does not resolve missing dynamic group membership or policy misconfiguration; it would only refresh the session's credentials if they were stale, but a 401 typically indicates a fundamental permission gap, not a transient token issue.

Practice this question →
9
MCQhard

An enterprise is using OCI Generative AI with a RAG architecture. They observe that the LLM sometimes produces hallucinated answers that are not supported by the retrieved documents. Which strategy is most effective in reducing these hallucinations?

A.Increase the temperature parameter to make outputs more focused.
B.Provide clear instructions in the system prompt to answer only based on the provided context.
C.Use a smaller LLM to reduce model capacity.
D.Retrieve more chunks (increase top-k) to provide more context.
AnswerB

Explicit grounding instructions guide the model to stick to retrieved documents, reducing unsupported claims.

Why this answer

Explicitly instructing the LLM to answer only based on the provided context directly addresses the root cause of hallucinations in a RAG pipeline: the model's tendency to rely on its parametric knowledge rather than the retrieved documents. This system prompt acts as a behavioral constraint, forcing the model to ground its responses in the supplied context, which is the most effective and widely recommended mitigation strategy.

Exam trap

Oracle often tests the misconception that increasing context quantity (top-k) or adjusting model parameters like temperature will solve hallucinations, when in fact the most reliable solution is explicit behavioral instruction through system prompts.

How to eliminate wrong answers

Option A is wrong because increasing the temperature parameter actually increases randomness and creativity in the output, making hallucinations more likely, not less; lower temperature values (closer to 0) produce more focused and deterministic outputs. Option C is wrong because using a smaller LLM reduces model capacity and may actually increase hallucination rates due to poorer reasoning and comprehension abilities, not decrease them. Option D is wrong because retrieving more chunks (increasing top-k) can introduce irrelevant or conflicting information that confuses the model, potentially increasing hallucinations rather than reducing them; the quality and relevance of retrieved chunks matter more than quantity.

Practice this question →
10
MCQhard

A DBA has created the above vector index. After running queries, they observe that recall is lower than expected for approximate searches. Which change would most likely improve recall while maintaining query performance?

A.Change the index type from IVF to HNSW.
B.Increase the TARGET ACCURACY value to 99.
C.Increase the number of neighbor partitions (NEIGHBOR PARTITIONS) to 8.
D.Reduce the number of neighbor partitions to 2.
AnswerB

A higher TARGET ACCURACY forces the approximate search to consider more vectors, increasing recall at the cost of some latency.

Why this answer

Increasing TARGET ACCURACY to 99 directly raises the recall threshold for approximate search, forcing the vector index to retrieve more candidates during the search phase. This improves recall without changing the index structure or query parallelism, so query performance (latency) is only minimally impacted compared to switching index types or drastically altering neighbor partitions.

Exam trap

Oracle often tests the misconception that changing the index type (e.g., IVF to HNSW) is the primary way to fix recall, when in fact TARGET ACCURACY is the direct parameter for recall tuning without altering the index structure.

How to eliminate wrong answers

Option A is wrong because switching from IVF to HNSW changes the underlying index algorithm, which can improve recall but often at the cost of higher memory usage and slower index build times, and it does not directly address the recall issue while maintaining existing query performance. Option C is wrong because increasing NEIGHBOR PARTITIONS to 8 expands the search scope, which improves recall but significantly degrades query performance (latency) due to scanning more partitions. Option D is wrong because reducing NEIGHBOR PARTITIONS to 2 narrows the search scope, which may improve query speed but will likely reduce recall further, opposite of the goal.

Practice this question →
11
MCQmedium

A company's RAG application ingests news articles that are updated frequently. The vector store in OCI OpenSearch contains embeddings of the articles. The team notices that outdated information is still retrieved even after updating the source documents. What is the most effective way to ensure the vector store reflects the latest content?

A.Increase the TTL for vector indices
B.Rely on the LLM to ignore outdated information
C.Re-index the entire vector store daily
D.Use the OCI OpenSearch document update API to replace embeddings for changed documents
AnswerD

Targeted updates minimize cost and ensure real-time accuracy.

Why this answer

Using the OCI OpenSearch document update API to replace embeddings for changed documents is efficient and targeted, ensuring immediate consistency.

Practice this question →
12
MCQhard

A company wants to build a multi-modal RAG system that can retrieve both text and images based on a user query. Which approach is most aligned with OCI GenAI capabilities?

A.Use OCI Document Understanding to convert images to text, then index text
B.Use separate vector stores for text and image embeddings
C.Use image captioning to generate text descriptions and index those
D.Utilize a multi-modal embedding model from OCI GenAI to embed both text and images into a common vector space
AnswerD

Multi-modal models enable direct retrieval of both types.

Why this answer

OCI GenAI supports multi-modal models like Cohere's multimodal embedding model, which can embed text and images into a shared vector space, enabling retrieval across modalities. Separate text and image models would not align the vectors. OCR-based text-only approach loses image semantics.

Using multiple vector stores complicates retrieval.

Practice this question →
13
MCQmedium

A developer receives the above error when querying a RAG application. What is the most likely cause and recommended action?

A.The API rate limit has been exceeded; wait for the retry period and implement exponential backoff.
B.The model is deprecated; update to the latest model.
C.The endpoint URL is incorrect; verify the OCI region endpoint.
D.The request payload is malformed; check the input format.
AnswerA

429 means rate limit.

Why this answer

The 429 (Too Many Requests) error indicates the API rate limit has been exceeded. In OCI Generative AI services, rate limits are enforced per tenancy and per region; the recommended action is to wait for the retry-after period and implement exponential backoff to avoid overwhelming the service.

Exam trap

Oracle often tests the distinction between HTTP status codes (429 vs 400 vs 404 vs 410) to see if candidates can map the exact error to the correct cause rather than guessing based on general troubleshooting.

How to eliminate wrong answers

Option B is wrong because a model deprecation would return a 404 or 410 error, not a 429. Option C is wrong because an incorrect endpoint URL would result in a 404 or connection timeout, not a rate-limit error. Option D is wrong because a malformed payload would produce a 400 Bad Request error, not a 429.

Practice this question →
14
MCQmedium

A company is building a RAG application using OCI Generative AI and OCI Search with OpenSearch. Users report that the responses from the LLM are not relevant to the queries, even though the document chunks seem appropriate. What is the most likely cause?

A.The embedding model is not suited for the domain.
B.Reranking is not enabled in the OpenSearch query.
C.The top K value is set too high.
D.The chunk size is too small, causing loss of context.
AnswerB

Reranking reorders search results for better relevance, significantly impacting quality.

Why this answer

Enabling reranking improves the relevance of retrieved documents by reordering them based on semantic match with the query. Without reranking, the initial vector search results may not be optimally ordered.

Practice this question →
15
Multi-Selecteasy

Which TWO are best practices for building a RAG application on OCI? (Choose two.)

Select 2 answers
A.Use a vector database such as OCI OpenSearch with ANN indexes for storing embeddings.
B.Generate embeddings for documents at query time to ensure freshness.
C.Pre-index the documents and update the index periodically to reflect new content.
D.Store the source documents only in OCI Object Storage and retrieve them at query time using full-text search.
E.Use a different embedding model for documents and queries to capture distinct semantics.
AnswersA, C

ANN indexes enable fast similarity search.

Why this answer

OCI OpenSearch with Approximate Nearest Neighbor (ANN) indexes is a best practice for vector storage and retrieval in RAG applications. ANN indexes enable efficient similarity search over high-dimensional embeddings, which is essential for retrieving relevant context from large document collections at low latency.

Exam trap

Oracle often tests the misconception that real-time embedding generation or full-text search can substitute for precomputed vector indexes in RAG, when in practice latency and semantic alignment requirements make pre-indexing and ANN search mandatory.

Practice this question →
16
Multi-Selectmedium

Which THREE factors should be considered when designing a chunking strategy for a RAG application?

Select 3 answers
A.Desired granularity of retrieval
B.Number of GPUs available
C.Database indexing method
D.Document structure
E.Embedding model's maximum input tokens
AnswersA, D, E

Smaller chunks allow more precise retrieval; larger chunks provide more context.

Why this answer

The desired granularity of retrieval determines how much context is returned per chunk. Fine-grained chunks (e.g., sentences) improve precision for specific answers, while coarse chunks (e.g., paragraphs) provide broader context. This directly impacts the relevance and completeness of the retrieved passages in a RAG pipeline.

Exam trap

A common misconception is that hardware resources like GPUs influence data preprocessing decisions, but chunking is purely a data design choice independent of compute capacity.

Practice this question →
17
Multi-Selecteasy

Which TWO of the following are valid approaches to serve a RAG application in OCI with low latency?

Select 2 answers
A.Pre-compute embeddings and answers for all possible questions.
B.Deploy the vector store on multiple regions to reduce network latency.
C.Increase the chunk size to reduce the number of retrievals.
D.Implement a caching layer for frequently asked questions.
E.Use an LLM that supports streaming response for faster user feedback.
AnswersD, E

Caching avoids redundant retrieval and generation, reducing latency for common queries.

Why this answer

Implementing a caching layer for frequently asked questions reduces redundant LLM invocations and vector store queries, directly lowering latency for repeated queries. This approach leverages in-memory caches like Redis or Memcached to serve precomputed responses, bypassing the retrieval and generation pipeline for cached items.

Exam trap

Oracle often tests the misconception that increasing chunk size or pre-computing all answers are viable latency solutions, when in fact they introduce precision loss or impracticality, while caching and streaming are the architecturally sound approaches for low-latency RAG serving.

Practice this question →
18
MCQmedium

A manufacturing company uses OCI OpenSearch to build a RAG application that retrieves procedural documents. After deployment, queries often return outdated procedures even though the vector index was refreshed. What is the most likely cause?

A.The embedding model was fine-tuned on outdated data.
B.The full-text search index is not synchronized with the vector index after updates.
C.The BM25 scoring algorithm prioritizes older documents due to term frequency.
D.The chunk overlap percentage is too high, causing duplicate context.
AnswerB

Outdated procedures remain in the text index if not reindexed.

Why this answer

In a RAG application using OCI OpenSearch, the vector index and full-text search index are separate. When procedural documents are updated, the full-text search index may reflect changes immediately, but the vector index requires explicit re-indexing or synchronization to update embeddings. If the vector index is not refreshed after updates, queries can still retrieve outdated vector representations, leading to outdated results despite the index being refreshed.

Exam trap

The trap here is that candidates may assume 'refreshing the vector index' automatically synchronizes it with document updates, but in practice, vector indexes require explicit re-embedding and re-indexing, which is often overlooked in RAG architectures.

How to eliminate wrong answers

Option A is wrong because fine-tuning the embedding model on outdated data would affect all embeddings, not just those from refreshed documents, and the scenario specifies the vector index was refreshed, implying embeddings were regenerated. Option C is wrong because BM25 scoring is used for full-text search, not vector search; it prioritizes documents based on term frequency and inverse document frequency, not age, and would not cause outdated procedures to be returned if the vector index is correctly synchronized. Option D is wrong because chunk overlap percentage affects context continuity and duplication, not the freshness of retrieved data; high overlap might cause duplicate chunks but not outdated procedures.

Practice this question →
19
MCQmedium

A financial firm deploys a RAG application using OCI OpenSearch. They observe that the LLM sometimes generates incorrect answers that are not supported by the retrieved documents. Which technique directly addresses this issue?

A.Use a more detailed system prompt instructing the model to not make up information.
B.Increase the temperature parameter of the LLM to reduce creativity.
C.Implement a post-generation verification step that checks if the answer is grounded in the retrieved chunks.
D.Increase the number of retrieved documents to provide more context.
AnswerC

Directly verifies faithfulness.

Why this answer

It directly addresses the problem of hallucination by verifying that the LLM's output is factually supported by the retrieved documents. In a RAG pipeline, the LLM may still generate unsupported content even with good retrieval; a post-generation grounding check explicitly validates each claim against the source chunks, ensuring answer fidelity.

Exam trap

Oracle often tests the misconception that prompt engineering or parameter tuning alone can solve hallucination in RAG, when in fact a dedicated verification step is required to enforce factual grounding.

How to eliminate wrong answers

Option A is wrong because a more detailed system prompt instructing the model not to make up information is a soft constraint that LLMs can easily ignore, especially when the model is confident in its fabricated answer; it does not provide a deterministic mechanism to prevent hallucination. Option B is wrong because increasing the temperature parameter actually increases randomness and creativity, making hallucinations more likely; reducing temperature (closer to 0) would make outputs more deterministic and less creative, but it still does not guarantee grounding in retrieved documents. Option D is wrong because increasing the number of retrieved documents can introduce irrelevant or conflicting context, potentially confusing the LLM and increasing the chance of unsupported answers; it does not enforce that the final answer is actually supported by any specific chunk.

Practice this question →
20
MCQhard

A team is deploying a RAG system that uses OCI Generative AI to answer questions about internal HR policies. The system must comply with data residency requirements: all data processing must stay within a specific OCI region. The team uses OCI Data Science for orchestration. Which architecture BEST meets the data residency requirement?

A.Deploy the generative AI model endpoints within the same OCI region as the data and compute.
B.Use OCI Generative AI endpoints in a different region but store data in the required region.
C.Use an external third-party LLM endpoint that guarantees data residency.
D.Store embeddings in a different region but run inference in the required region.
AnswerA

All components remain in the specified region, ensuring compliance.

Why this answer

Deploying the generative AI model endpoints within the same OCI region as the data and compute ensures that all data processing—including inference, embedding generation, and vector search—occurs entirely within the required region, satisfying data residency requirements. OCI Generative AI endpoints are region-specific and do not automatically route requests to other regions, so co-locating all components avoids any cross-region data transfer.

Exam trap

Oracle often tests the misconception that data residency only applies to storage, not to processing—candidates may think storing data in the required region is sufficient, but the trap is that inference and embedding generation also count as data processing and must occur in the same region.

How to eliminate wrong answers

Option B is wrong because using OCI Generative AI endpoints in a different region while storing data in the required region would cause inference requests and model processing to occur outside the required region, violating data residency requirements. Option C is wrong because an external third-party LLM endpoint that guarantees data residency still requires data to leave the OCI region to reach the external service, which breaks the requirement that all data processing must stay within a specific OCI region. Option D is wrong because storing embeddings in a different region while running inference in the required region means the embedding data (derived from HR policies) resides outside the required region, failing the data residency constraint.

Practice this question →
21
MCQmedium

A healthcare organization plans to deploy a RAG application on OCI that handles sensitive patient data. They require that all LLM inference and embedding processing happen within a controlled environment to avoid data leakage to public endpoints. Which OCI feature should they use?

A.OCI Data Labeling
B.OCI Vault
C.OCI Data Masking
D.OCI Dedicated AI Cluster
AnswerD

Dedicated AI Cluster provides isolated compute for AI workloads.

Why this answer

OCI Dedicated AI Cluster provides a fully isolated, single-tenant infrastructure for running AI workloads, including LLM inference and embedding processing. This ensures all data processing occurs within a controlled environment without traversing public endpoints, meeting the healthcare organization's requirement to prevent data leakage of sensitive patient data.

Exam trap

The common trap in Oracle exams is that candidates may confuse data protection features like OCI Vault (encryption) or OCI Data Masking with the need for a private compute environment, failing to recognize that OCI Dedicated AI Cluster is the only option that physically isolates the AI processing pipeline from public networks.

How to eliminate wrong answers

Option A is wrong because OCI Data Labeling is a service for creating labeled datasets for machine learning, not for controlling where inference or embedding processing occurs. Option B is wrong because OCI Vault is a key management service for storing and managing encryption keys and secrets, not for isolating compute environments for AI workloads. Option C is wrong because OCI Data Masking is used to redact or obfuscate sensitive data in databases and files, not to provide a private compute environment for LLM inference.

Practice this question →
22
Multi-Selectmedium

Which TWO actions are best practices when deploying a RAG application using OCI OpenSearch and OCI Generative AI?

Select 2 answers
A.Embed every document chunk in real-time during query processing.
B.Implement a reranker to improve the relevance of retrieved documents.
C.Use very small chunk sizes (e.g., 50 tokens) to maximize granularity.
D.Monitor query latency and adjust the number of retrieved documents accordingly.
E.Set the LLM temperature to 1.5 to encourage diverse outputs.
AnswersB, D

Improves precision.

Why this answer

Implementing a reranker improves retrieval precision by re-scoring the top-k documents from the initial vector search using a cross-encoder model, which captures deeper semantic relevance than cosine similarity alone. In OCI OpenSearch, this is typically done via a post-processing step with OCI Generative AI or a dedicated reranking model, ensuring only the most contextually relevant chunks are passed to the LLM for generation.

Exam trap

Oracle often tests the misconception that real-time embedding (Option A) is efficient for RAG, when in fact pre-computed embeddings are standard, and that very small chunks (Option C) improve granularity, whereas they actually harm context coherence and retrieval quality.

Practice this question →
23
MCQhard

A healthcare startup is building a chatbot that retrieves patient treatment guidelines using OCI Generative AI Service and OCI OpenSearch. They require that all retrieved documents are from approved sources only and that the system can explain which source was used for each response. Which combination of features should they implement?

A.Add a metadata filter for source_type='approved' in the retrieval step and include document IDs in the context for the model.
B.Rely on the vector search's cosine similarity to rank approved sources higher.
C.Use prompt engineering to ask the model to ignore non-approved sources.
D.Reduce the top-K value to limit the number of retrieved documents.
AnswerA

Metadata filtering enforces source restriction; document IDs provide provenance.

Why this answer

It directly addresses both requirements: a metadata filter on `source_type='approved'` ensures only approved documents are retrieved from OpenSearch, and including document IDs in the context allows the model to cite the specific source for each response. This approach enforces access control at the retrieval layer while providing traceability, which is essential for compliance in healthcare applications.

Exam trap

The trap here is that candidates may assume semantic similarity or prompt engineering alone can enforce access control, but in RAG systems, retrieval-layer filtering is the only reliable way to restrict document access before the model sees the content.

How to eliminate wrong answers

Option B is wrong because cosine similarity measures semantic relevance, not source approval status; approved and non-approved documents can be equally similar to a query, so ranking by similarity alone cannot guarantee that only approved sources are used. Option C is wrong because prompt engineering cannot reliably filter out non-approved sources; the model may still see and inadvertently use non-approved content in its context, and it has no inherent mechanism to verify source approval. Option D is wrong because reducing the top-K value limits the number of retrieved documents but does not enforce any approval criterion; non-approved documents can still appear in the top-K results if they are semantically similar.

Practice this question →
24
MCQhard

You are a cloud architect at a global e-commerce company. The company is building a RAG-based product support chatbot using OCI Generative AI Service and OCI OpenSearch. The chatbot must answer customer questions in real-time by retrieving from a product knowledge base containing over 10 million documents. The current architecture uses a single vector index with all documents, and the LLM (Cohere Command R+) returns answers in English only. The team observes that queries from non-English customers often return irrelevant results, and the chatbot sometimes fails to generate answers within the 5-second SLA. The leadership wants to support 10 languages and reduce the average response time to under 3 seconds. You need to propose a solution that improves both relevance and latency. Which course of action should you take?

A.Increase the number of OCI OpenSearch nodes and upgrade the LLM to a faster variant.
B.Replace the embedding model with a multilingual model and partition the vector index by language to reduce search space.
C.Translate all non-English queries to English before retrieval and use an English-only embedding model.
D.Implement a caching layer for frequent queries and use a larger LLM for better accuracy.
AnswerB

Multilingual model improves relevance; partitioning improves latency.

Why this answer

Partitioning the vector index by language reduces the search space for each query, directly improving retrieval latency, while using a multilingual embedding model ensures that non-English queries are semantically matched to documents in their original language, improving relevance. This combination addresses both the 3-second SLA and the 10-language requirement without relying on translation, which introduces latency and potential loss of meaning.

Exam trap

The trap here is that candidates often assume translation is the simplest path to multilingual support, overlooking the latency and semantic drift it introduces, and fail to recognize that partitioning the index is a standard optimization for both relevance and speed in large-scale RAG systems.

How to eliminate wrong answers

Option A is wrong because simply scaling nodes and upgrading the LLM does not fix the root cause of irrelevant results for non-English queries—the embedding model remains English-only, so multilingual queries will still map poorly in vector space. Option C is wrong because translating all non-English queries to English before retrieval adds significant latency (often 200-500ms per translation) and can lose cultural or contextual nuances, making it unsuitable for a 3-second SLA and 10-language support. Option D is wrong because a caching layer only helps with repeated queries, not novel ones, and using a larger LLM increases inference latency, making it harder to meet the 3-second target; it also does not address the embedding mismatch for non-English content.

Practice this question →
25
MCQhard

A team fine-tunes an embedding model for a legal document RAG system but observes low retrieval recall. Which technique is most likely to improve recall?

A.Use a smaller batch size
B.Use hard negative mining during training
C.Reduce the learning rate
D.Increase the number of fine-tuning epochs
AnswerB

Hard negatives force the model to differentiate between similar but irrelevant documents, improving retrieval discrimination.

Why this answer

Hard negative mining exposes the model to challenging negatives during training, which sharpens the embedding space and improves recall.

Practice this question →
26
MCQmedium

Refer to the exhibit. A developer runs the command and immediately tries to use the endpoint. The application fails with an error indicating the endpoint is not active. What is the most likely reason?

A.The model ID is not available in us-ashburn-1
B.The purpose parameter is misspelled
C.The endpoint is in provisioning state and not yet ready
D.The compartment ID is incorrect
AnswerC

Endpoints take time to provision; using them immediately fails.

Why this answer

When a developer creates a new model deployment endpoint in OCI, the endpoint enters a 'provisioning' state and can take several minutes to become active. Attempting to use the endpoint immediately after creation will result in an error indicating the endpoint is not ready, as the underlying infrastructure and model loading must complete before inference requests are accepted.

Exam trap

Oracle often tests the asynchronous nature of OCI resource creation, where candidates mistakenly assume the endpoint is immediately usable after the create command returns a success response.

How to eliminate wrong answers

Option A is wrong because the model ID being unavailable in us-ashburn-1 would cause a different error during deployment creation, not an 'endpoint not active' error after the command runs. Option B is wrong because a misspelled 'purpose' parameter would cause a validation error at command submission time, not a runtime error when trying to use the endpoint. Option D is wrong because an incorrect compartment ID would result in an authorization or not-found error during the create command, not a post-creation 'endpoint not active' error.

Practice this question →
27
MCQmedium

A team uses Cohere's `rerank` endpoint after initial retrieval to improve result quality. What is the main benefit of reranking?

A.It generates new embeddings for chunks
B.It combines multiple queries
C.It reorders chunks by relevance to the query
D.It reduces the number of retrieved chunks
AnswerC

Reranking improves the ordering so the most relevant appear first.

Why this answer

The rerank endpoint takes the initial set of retrieved chunks and re-scores them based on their semantic relevance to the query, producing a reordered list where the most contextually appropriate chunks appear first. This improves the quality of the input fed to the LLM, leading to more accurate and coherent generated responses without altering the embeddings or the retrieval count.

Exam trap

Oracle often tests the distinction between retrieval and reranking, and the trap here is that candidates confuse reranking with reducing the number of chunks (Option D) or assume it modifies embeddings (Option A), when in fact it only reorders based on deeper relevance scoring.

How to eliminate wrong answers

Option A is wrong because reranking does not generate new embeddings; it uses the existing embeddings from the initial retrieval step to compute relevance scores. Option B is wrong because reranking operates on a single query against a set of retrieved chunks, not by combining multiple queries. Option D is wrong because reranking does not reduce the number of retrieved chunks; it reorders the existing set, and the number of chunks passed to the LLM remains the same unless explicitly truncated elsewhere.

Practice this question →
28
MCQhard

Refer to the exhibit. A developer has set this policy to allow an OCI Data Science session to generate embeddings. However, the API call returns a 403 Forbidden. Which of the following is likely missing?

A.The policy needs a 'where request.region != ...' condition
B.The policy should include 'in tenancy' instead of compartment
C.The service requires 'manage' permission instead of 'use'
D.The dynamic group does not include the Data Science session
AnswerD

The session must be matched by a rule in the dynamic group for the policy to apply.

Why this answer

The 403 Forbidden error indicates that the Data Science session does not have the necessary permissions to call the API. In OCI, policies grant permissions to dynamic groups, not directly to resources. The dynamic group must include the Data Science session (e.g., by matching the session's OCID or resource type) for the policy to apply.

Without this, the session is not recognized as a principal, and the API call is denied.

Exam trap

Oracle often tests the distinction between policy syntax correctness and dynamic group membership, leading candidates to focus on permission levels or scope when the real issue is that the resource (Data Science session) is not a member of the dynamic group referenced in the policy.

How to eliminate wrong answers

Option A is wrong because adding a 'where request.region != ...' condition would restrict the policy to specific regions, but the core issue is that the session is not authorized at all, not that it's in the wrong region. Option B is wrong because 'in tenancy' would broaden the scope to all compartments, but the policy already targets a specific compartment; the problem is the dynamic group membership, not the scope. Option C is wrong because 'use' permission is sufficient for generating embeddings (which is a read/use operation), and 'manage' would be excessive; the error is not about permission level but about the principal not being authorized.

Practice this question →
29
MCQmedium

A company is deploying a RAG system for internal document search using OCI OpenSearch as the vector store. Users report that queries about recent policy changes return no results, even though the new policies were ingested. Which configuration is most likely missing?

A.The query should use a hybrid search combining keyword and vector.
B.The embeddings must be normalized before indexing.
C.The vector search index must have a refresh interval set to immediate.
D.The ingestion pipeline should use a text-splitting chunker.
AnswerC

Without immediate refresh, new documents may not be visible in search results.

Why this answer

OCI OpenSearch by default has a refresh interval (e.g., 1 second), which means recently ingested documents may not appear in search results immediately. Setting the refresh interval to 'immediate' forces the index to refresh after every write, making new documents searchable right away. Option A (hybrid search) improves relevance but does not affect document availability.

Option B (normalizing embeddings) is important for cosine similarity but not for search availability. Option D (text-splitting chunker) is a preprocessing step for ingestion but does not control when documents become searchable.

Practice this question →
30
MCQmedium

You are a data scientist at a legal firm. The firm uses OCR to digitize court documents and then indexes them in OCI OpenSearch for a RAG application. The application uses OCI Generative AI Service (Cohere Command) to answer questions about case law. Recently, the team noticed that the answers are often factually incorrect or include information not present in the retrieved documents. After reviewing the pipeline, you find that the chunking strategy splits documents into 512-token chunks with 128-token overlap. The embedding model is Cohere Embed v3 (English), and the retrieval returns the top 5 chunks. The LLM has a context window of 4096 tokens. The team suspects that the chunking strategy is causing loss of context. What is the best course of action to improve answer accuracy?

A.Increase the chunk size to 1024 tokens and overlap to 256 tokens.
B.Reduce the chunk overlap to 64 tokens to avoid redundancy.
C.Switch to a smaller LLM with a larger context window.
D.Increase the number of retrieved chunks from 5 to 10.
AnswerA

Larger chunks with more overlap preserve context better.

Why this answer

Increasing the chunk size to 1024 tokens and overlap to 256 tokens directly addresses the loss of context by ensuring each chunk contains more complete semantic units (e.g., entire paragraphs or legal arguments) while the larger overlap preserves continuity across chunk boundaries. This improves the quality of the embeddings and the relevance of retrieved chunks, leading to more factually accurate answers from the LLM.

Exam trap

The trap here is that candidates may assume increasing retrieval count (Option D) always improves accuracy, but in RAG systems, more chunks often introduce noise and dilute relevant context, whereas fixing the chunking strategy directly addresses the root cause of context loss.

How to eliminate wrong answers

Option B is wrong because reducing the overlap to 64 tokens would further fragment context, increasing the risk of missing critical information at chunk boundaries and worsening the factual inaccuracies. Option C is wrong because switching to a smaller LLM with a larger context window does not fix the root cause—poor chunking—and a smaller model may have lower reasoning capability, potentially degrading answer quality. Option D is wrong because increasing the number of retrieved chunks from 5 to 10 would introduce more noise and irrelevant content into the LLM's context, likely amplifying hallucinations rather than improving accuracy.

Practice this question →
31
MCQmedium

An OCI CLI command above returns embeddings for the phrase 'Hello world'. The developer notices that the embedding vector length is 384 dimensions. However, they expected 768 dimensions. What is the most likely cause?

A.The input text 'Hello world' is too short, causing dimension reduction.
B.The CLI result is truncated in the display.
C.The model 'cohere.embed-multilingual-light-v3.0' outputs 384-dimensional vectors.
D.The --truncate END flag reduces the dimension.
AnswerC

This specific model produces 384 dimensions; the 'light' version is smaller.

Why this answer

The Cohere model 'cohere.embed-multilingual-light-v3.0' is specifically designed to output 384-dimensional embeddings. The developer's expectation of 768 dimensions likely stems from familiarity with larger models like 'cohere.embed-english-v3.0', which outputs 1024 dimensions, or other models that produce 768-dimensional vectors. The embedding dimension is a fixed property of the model, not influenced by input length or CLI display settings.

Exam trap

Oracle often tests the misconception that embedding dimension is dynamically determined by input length or CLI flags, when in fact it is a static property of the chosen model.

How to eliminate wrong answers

Option A is wrong because embedding dimension is a fixed property of the model and does not change based on input text length; short inputs do not cause dimension reduction. Option B is wrong because the CLI does not truncate the embedding vector in the display; the full vector is returned, and any display truncation would be cosmetic and not affect the actual dimension count. Option D is wrong because the --truncate END flag controls how the input text is truncated to fit the model's token limit, not the output embedding dimension.

Practice this question →
32
Multi-Selecthard

Which THREE factors directly influence the quality of responses in a RAG system? (Choose three.)

Select 3 answers
A.The prompt template used to ask the LLM
B.The chunk size used during document processing
C.The temperature parameter of the LLM
D.The number of GPUs allocated to the LLM
E.The choice of embedding model
AnswersA, B, E

A well-structured prompt helps the LLM use the context properly.

Why this answer

The prompt template directly controls how the LLM interprets the retrieved context and formulates its response. A well-structured prompt with clear instructions, context formatting, and output constraints significantly improves response relevance and accuracy, while a poorly designed prompt can lead to hallucinations or off-topic answers.

Exam trap

Oracle certification exams often test the distinction between factors that directly influence response quality (prompt, chunk size, embedding model) versus factors that affect performance or output style (temperature, GPU count), leading candidates to mistakenly select temperature or hardware options.

Practice this question →
33
MCQeasy

A developer is using OCI Data Science to create a RAG pipeline. They have ingested documents into a vector store using OCI Generative AI's text-embedding model. During testing, they notice that queries return very few results (often 0 or 1) even when the knowledge base contains relevant documents. They have set the top-k parameter to 10. What is the most likely cause?

A.The similarity threshold is set too high, filtering out most results.
B.The documents were chunked with too small a chunk size, losing key information.
C.The embedding model's dimensionality is too low to capture semantic differences.
D.The vector search index is not configured with the correct distance metric.
AnswerA

A high similarity threshold filters out many results, causing very few to pass.

Why this answer

A high similarity threshold (e.g., >0.9) can exclude many relevant results, leading to few or zero results even with top-k set to 10. Option B: chunk size affects the granularity of text but not directly the number of results returned; small chunks can still be retrieved if the threshold is appropriate. Option C: dimensionality of the embedding model is fixed and does not directly cause zero results; low dimensionality may reduce semantic precision but not eliminate results.

Option D: distance metric affects how similarity is computed but not the count; the index can still return results ranked by the chosen metric.

Practice this question →
34
MCQhard

An application mixes RAG with other data sources. The vector search returns too many irrelevant chunks. What is the best approach to filter them?

A.Use a reranker model
B.Use exact search instead of ANN
C.Reduce the number of retrieved chunks
D.Increase chunk size
AnswerA

A reranker scores retrieved chunks by relevance, filtering out irrelevant ones.

Why this answer

A reranker model (Option A) is the best approach because it takes the initial set of retrieved chunks and re-orders them based on semantic relevance to the query, effectively filtering out irrelevant chunks. Unlike simple vector similarity, a reranker uses cross-encoding to evaluate the query-chunk pair as a whole, which significantly improves precision when mixing RAG with other data sources.

Exam trap

Oracle often tests the misconception that reducing the number of retrieved chunks (Option C) is a valid filter, but the trap is that this only limits output size without improving relevance—reranking is the correct technique to reorder and discard irrelevant results.

How to eliminate wrong answers

Option B is wrong because exact search (e.g., brute-force k-NN) retrieves the same chunks as ANN but without approximation; it does not filter irrelevant chunks—it only guarantees the true nearest neighbors, which may still be irrelevant if the vector representation is poor. Option C is wrong because reducing the number of retrieved chunks (e.g., lowering top_k) risks missing relevant chunks and does not address the core problem of irrelevant chunks being ranked too high. Option D is wrong because increasing chunk size makes each chunk more likely to contain irrelevant content, potentially worsening the problem by diluting relevant information with noise.

Practice this question →
35
MCQeasy

A developer wants to implement a simple RAG pipeline using OCI Language's text generation and embedding models. Which OCI SDK method is used to generate embeddings for a text chunk?

A.embed_text
B.generate_embeddings
C.encode_text
D.create_embedding
AnswerA

`embed_text` is the correct method to call for generating embeddings from text.

Why this answer

The correct OCI SDK method for generating embeddings for a text chunk is `embed_text`. This method is part of the OCI Language service's `AIServiceLanguageClient` and directly returns vector representations of input text, which are essential for RAG pipelines to enable semantic search and retrieval.

Exam trap

The trap here is that candidates confuse OCI SDK method names with those from other cloud providers (e.g., OpenAI's `create_embedding` or generic `encode_text`), leading them to select a plausible-sounding but incorrect option.

How to eliminate wrong answers

Option B is wrong because `generate_embeddings` is not a valid method in the OCI Language SDK; the correct method name is `embed_text`. Option C is wrong because `encode_text` is not an OCI SDK method; it resembles a generic function name from other frameworks (e.g., Hugging Face) but does not exist in OCI's API. Option D is wrong because `create_embedding` is not an OCI SDK method; it is a method name used by OpenAI's API, not by OCI Language.

Practice this question →
36
Multi-Selectmedium

Which TWO of the following are best practices when implementing a RAG application using OCI OpenSearch as a vector store?

Select 2 answers
A.Use a large embedding dimension (e.g., 1536) to improve accuracy.
B.Set index.number_of_replicas to 0 to speed up indexing.
C.Enable approximate nearest neighbor (ANN) search for large datasets.
D.Store the embedding vectors in the _source field to simplify retrieval.
E.Use cosine similarity as the distance metric for vector comparison.
AnswersC, E

ANN search significantly reduces query latency for large vector collections.

Why this answer

For large datasets, exact nearest neighbor (k-NN) search becomes computationally expensive and slow. OCI OpenSearch supports approximate nearest neighbor (ANN) search using algorithms like HNSW, which dramatically reduce latency while maintaining high recall, making it essential for production RAG applications with millions of vectors.

Exam trap

A common trap is the misconception that larger embedding dimensions always improve accuracy, when in fact the dimension should match the model's output (e.g., 768 for all-MiniLM-L6-v2) and larger dimensions increase cost without proportional benefit.

Practice this question →
37
Multi-Selectmedium

Which TWO are required components to implement a basic RAG system using OCI services? (Choose two.)

Select 2 answers
A.OCI Object Storage
B.OCI Functions
C.OCI Data Flow
D.OCI Search with OpenSearch
E.OCI Document Understanding
AnswersD, E

Required as the vector database for similarity search.

Why this answer

A RAG system needs a way to parse documents into chunks (OCI Document Understanding) and a vector store to index and search embeddings (OCI Search with OpenSearch).

Practice this question →
38
Multi-Selecthard

A developer is troubleshooting low recall in a vector search. Which THREE factors should be checked? (Choose three.)

Select 3 answers
A.Embedding model quality and relevance to domain
B.Chunk size and overlap strategy
C.Quality of the query embedding generation
D.The number of results returned (k) in the search
E.The LLM's temperature setting
AnswersA, B, C

A model not trained on similar data may produce poor embeddings.

Why this answer

The embedding model's quality and domain relevance directly determine how well semantic relationships are captured. If the model is not fine-tuned on domain-specific data, it may fail to map similar concepts close together in the vector space, leading to low recall. For example, a general-purpose model may not distinguish between 'bank' as a financial institution versus a river bank in a legal document search.

Exam trap

Oracle often tests the misconception that retrieval parameters like k or generation parameters like temperature affect recall, when in fact recall is primarily determined by embedding quality, chunking strategy, and query embedding fidelity.

Practice this question →
39
MCQhard

A company is using OCI Generative AI for a RAG-based code assistant. They index source code repositories into a vector store. Developers report that the assistant often suggests deprecated APIs or outdated code snippets, even though the latest code is in the repository. The index was built a week ago and has not been updated. They plan to set up incremental updates. However, they notice that even after re-indexing the latest commits, the issue persists. What is the most likely oversight?

A.The vector store is not configured to overwrite existing vectors for updated documents.
B.The retrieval top-k is set too low, missing some relevant snippets.
C.The chunking strategy splits code at function boundaries, losing import statements.
D.The embedding model is not fine-tuned on code; it was trained on natural language.
AnswerA

Without overwrite, old vectors persist even after re-indexing, causing retrieval of outdated code.

Why this answer

If the vector store does not overwrite or update vectors for changed documents, old vectors remain, causing retrieval of outdated code. Option B (chunking at function boundaries) may cause missing imports but not specifically deprecation. Option C (embedding model not fine-tuned on code) might affect quality but not freshness.

Option D (low top-k) would affect recall, not freshness.

Practice this question →
40
MCQhard

A team is optimizing a RAG pipeline for OCI Generative AI. They observe that the model's responses are verbose and often include irrelevant details from the retrieved chunks, reducing user satisfaction. They have already tuned the prompt template. What is the most effective next step?

A.Apply instruction tuning on the generation model.
B.Implement a re-ranking step using a cross-encoder model.
C.Reduce the number of retrieved chunks from 5 to 3.
D.Increase the similarity threshold for retrieval from 0.7 to 0.85.
AnswerB

Re-ranking scores each chunk for relevance to the query, filtering out noise.

Why this answer

Implementing a re-ranking step with a cross-encoder model directly addresses the problem of verbose and irrelevant responses. Cross-encoders evaluate the query-document pair jointly, producing a fine-grained relevance score that filters out noisy or off-topic chunks before they reach the generation model. This improves the quality of the context provided to the LLM, reducing verbosity and irrelevance without requiring retraining or altering the retrieval threshold.

Exam trap

OCI GenAI exams often test the misconception that adjusting retrieval parameters (threshold or count) is sufficient to fix relevance issues, when in fact a dedicated re-ranking step is needed to refine the quality of the context passed to the generation model.

How to eliminate wrong answers

Option A is wrong because instruction tuning is a resource-intensive process that modifies the generation model itself, requiring a curated dataset and significant compute; it is not a lightweight next step and does not directly address the retrieval quality issue. Option C is wrong because simply reducing the number of retrieved chunks from 5 to 3 may discard relevant information while still allowing irrelevant chunks to pass through; it does not improve the relevance ranking of the chunks that are kept. Option D is wrong because increasing the similarity threshold from 0.7 to 0.85 may cause the retrieval step to miss relevant chunks that have lower cosine similarity scores, potentially reducing recall and still not filtering out irrelevant chunks that happen to score above the threshold.

Practice this question →
41
Multi-Selecteasy

Which TWO of the following are valid similarity metrics used in vector search?

Select 2 answers
A.Levenshtein distance
B.Cosine similarity
C.Euclidean distance
D.Hamming distance
E.Jaccard index
AnswersB, C

Commonly used for normalized vectors.

Why this answer

Cosine similarity measures the cosine of the angle between two vectors, focusing on orientation rather than magnitude. It is widely used in vector search for comparing embeddings because it effectively captures semantic similarity in high-dimensional spaces, such as those produced by LLMs.

Exam trap

Oracle often tests the distinction between distance metrics (like Euclidean) and similarity metrics (like cosine), and candidates may mistakenly treat all distance-based measures as valid similarity metrics for vector search, overlooking that some are designed for strings or sets rather than continuous vectors.

Practice this question →
42
MCQhard

A healthcare company is building a RAG-based chatbot to answer patient queries using medical documents stored in OCI Object Storage. They use OCI Generative AI service with Cohere Command R+ model and OCI OpenSearch as the vector database. The chatbot is deployed on OCI Compute with a Flask application. After deployment, the latency for each query is 15-20 seconds, which is unacceptable. Logs show that the embedding generation step (using OCI Generative AI embedding API) takes 8-10 seconds, and the vector search in OpenSearch takes 5-7 seconds. The team has already enabled connection pooling and increased the compute instance shape to the maximum allowed. Which action would MOST effectively reduce the overall latency?

A.Pre-generate embeddings for all documents during ingestion and store them in the vector database, so at query time only the query embedding is generated and compared.
B.Implement a caching layer with Redis to store previous query results and serve cached responses for identical queries.
C.Reindex the OpenSearch vector index with optimal settings (e.g., HNSW algorithm, ef_search param) to speed up vector search.
D.Switch to a faster embedding model like Cohere Embed v3 (English) which has lower latency.
AnswerA

This eliminates the need to generate embeddings for each document during the query path, drastically reducing latency.

Why this answer

The primary bottleneck is the embedding generation step (8-10 seconds). By pre-generating embeddings for all documents during ingestion and storing them in the vector database, the query-time embedding generation is eliminated, reducing the per-query latency to only the time needed to generate the query embedding and perform the vector search. This directly addresses the largest contributor to the 15-20 second latency.

Exam trap

The trap here is that candidates may focus on optimizing the vector search or caching responses, but the real bottleneck is the embedding generation step, which must be eliminated at query time through pre-generation during ingestion.

How to eliminate wrong answers

Option B is wrong because caching previous query results only helps for repeated identical queries, not for the vast majority of unique patient queries, and does not address the embedding generation bottleneck. Option C is wrong because while tuning HNSW parameters (like ef_search) can improve vector search speed, it only targets the 5-7 second search step, not the 8-10 second embedding generation step, so the overall latency reduction would be insufficient. Option D is wrong because switching to a faster embedding model may reduce embedding latency slightly, but the core issue is that embedding generation is still performed at query time for every query; pre-generation is a more fundamental optimization that eliminates the per-query embedding cost entirely.

Practice this question →
43
MCQeasy

A developer is building a RAG application using Oracle Cloud Infrastructure (OCI) Document Understanding and OCI Generative AI. After chunking documents and generating embeddings, the developer observes that the retrieval step often returns chunks that are semantically unrelated to the query. Which action is MOST likely to improve retrieval relevance?

A.Switch from a dense embedding model to a sparse embedding model.
B.Adjust the chunk size and chunk overlap to better capture coherent passages.
C.Increase the chunk size to capture more context.
D.Reduce the number of retrieved chunks (k) in the vector search.
AnswerB

Adjusting chunk size and overlap directly improves chunk coherence, making retrieved passages more semantically related to the query.

Why this answer

Adjusting chunk size and overlap helps create coherent chunks that align with query intent, improving retrieval relevance. Option A is wrong because the embedding model type (dense vs. sparse) affects retrieval method but does not directly fix chunk coherence issues. Option C is wrong because increasing chunk size may introduce noise and irrelevant context.

Option D is wrong because reducing the number of retrieved chunks (k) only limits results, not improves relevance of individual chunks.

Practice this question →
44
MCQmedium

An organization stores its knowledge base in Oracle Autonomous Database and wants to build a RAG chatbot using OCI Generative AI. The chatbot must retrieve the most relevant documents based on user queries. Which indexing approach is BEST suited for efficient similarity search on text embeddings?

A.Create an ANN index on the embedding vector column.
B.Create a bitmap index on the embedding vector column.
C.Create an inverted index on the document text column.
D.Create a B-tree index on the document text column.
AnswerA

ANN indexes enable fast approximate nearest neighbor search in vector databases.

Why this answer

Approximate Nearest Neighbor (ANN) indexes are specifically designed for high-dimensional vector spaces, enabling efficient similarity search on embedding vectors. In Oracle Autonomous Database, ANN indexes (e.g., using IVF or HNSW algorithms) drastically reduce search latency compared to brute-force scans, which is critical for real-time RAG chatbot responses.

Exam trap

Oracle often tests the misconception that any index type can be applied to vector columns, but the trap here is that candidates confuse traditional database indexes (B-tree, bitmap, inverted) with specialized vector indexes, failing to recognize that only ANN indexes support distance-based similarity search on embeddings.

How to eliminate wrong answers

Option B is wrong because bitmap indexes are optimized for low-cardinality columns (e.g., gender or status flags), not for high-dimensional floating-point vectors, and they cannot perform similarity comparisons like cosine or Euclidean distance. Option C is wrong because inverted indexes are designed for full-text search on tokenized text, not for vector embeddings, and they cannot compute distances between vectors. Option D is wrong because B-tree indexes are for exact match or range queries on scalar data (e.g., numbers or short strings), and they do not support the distance-based ordering required for vector similarity search.

Practice this question →
45
MCQmedium

An enterprise RAG system must ensure that retrieved data comes only from authorized sources. Which OCI feature should be used to enforce this?

A.Data encryption at rest
B.OCI IAM policies for the vector database
C.Network security groups
D.Resource quotas
AnswerB

IAM policies control who can access the vector database and its data.

Why this answer

OCI IAM policies allow you to define granular access controls on the vector database, ensuring that only authorized principals (users, groups, or service principals) can read or write data. This directly enforces that retrieved data comes only from authorized sources, which is a core requirement for enterprise RAG systems.

Exam trap

The trap here is that candidates confuse network-level controls (NSGs) with identity-based access controls (IAM), mistakenly thinking that restricting network traffic is sufficient to enforce data source authorization in a RAG pipeline.

How to eliminate wrong answers

Option A is wrong because data encryption at rest protects data confidentiality when stored, but does not control which sources or users are authorized to retrieve the data. Option C is wrong because network security groups control network traffic at the subnet or VNIC level, not the authorization of data retrieval from a vector database. Option D is wrong because resource quotas limit the number or size of resources, not the authorization of data access.

Practice this question →
46
MCQmedium

A document processing pipeline uses OCI Document Understanding to extract text from PDFs, then creates embeddings with OCI Generative AI. Some documents exceed the embedding model's token limit. What is the best approach?

A.Truncate the document to the token limit
B.Use a different embedding model with a higher token limit
C.Skip documents that exceed the limit
D.Split the document into chunks that fit the limit and embed each chunk separately
AnswerD

Chunking preserves full content and allows granular retrieval.

Why this answer

Splitting documents into chunks that fit within the embedding model's token limit ensures that no information is lost while still allowing each chunk to be embedded and indexed separately. This approach is standard in RAG pipelines, where documents are chunked to balance token limits and retrieval granularity, enabling the system to retrieve relevant chunks rather than entire documents.

Exam trap

The trap here is that candidates often assume truncation (Option A) is acceptable because it's simple, but they overlook the critical loss of information that undermines retrieval accuracy in RAG systems.

How to eliminate wrong answers

Option A is wrong because truncating the document discards potentially critical information, leading to incomplete embeddings and degraded retrieval performance in RAG. Option B is wrong because switching to a different embedding model with a higher token limit does not solve the fundamental issue of variable-length documents; even with a higher limit, some documents may still exceed it, and it may not be practical or cost-effective to change models. Option C is wrong because skipping documents that exceed the limit results in data loss, which undermines the completeness of the knowledge base and can cause the RAG system to miss relevant information.

Practice this question →
47
Multi-Selecthard

Which TWO are common causes of poor answer quality in a RAG system built on OCI Generative AI? (Choose two.)

Select 2 answers
A.Mismatch between the embedding model's training data and the domain of the documents.
B.Using a generation model that is too large for the task.
C.Setting the temperature parameter too low, causing overly deterministic outputs.
D.Insufficient number of relevant chunks in the document corpus for the given query.
E.Using only vector search without keyword-based fallback.
AnswersA, D

Domain mismatch leads to poor semantic alignment and irrelevant retrieval.

Why this answer

The embedding model's training data determines the semantic space in which documents and queries are represented. If the model was trained on general text (e.g., Wikipedia) but the documents are from a specialized domain (e.g., medical or legal), the embeddings will fail to capture domain-specific nuances, leading to poor retrieval relevance and thus poor answer quality in the RAG system.

Exam trap

Oracle often tests the distinction between retrieval-side failures (like embedding mismatch or insufficient chunks) and generation-side parameters (like temperature or model size), so candidates mistakenly attribute poor answer quality to generation settings rather than the retrieval pipeline.

Practice this question →
48
MCQmedium

A legal firm needs an AI assistant that can answer questions based on a large corpus of internal regulations that change quarterly. The firm also requires high accuracy and the ability to cite sources. Which approach should the firm choose?

A.Build a RAG application with vector search and citation generation
B.Use a pre-trained model without customization
C.Implement a rule-based search engine
D.Fine-tune a pre-trained model on the current regulations
AnswerA

RAG retrieves relevant documents and can cite sources, and updating the knowledge base is straightforward.

Why this answer

Retrieval-Augmented Generation (RAG) with vector search allows the legal firm to index its quarterly-changing regulations into a vector database, retrieve the most relevant chunks for each query, and generate answers with source citations. This approach ensures high accuracy by grounding the LLM's output in the current, authoritative documents without requiring retraining, and citation generation provides the necessary source traceability for legal compliance.

Exam trap

Oracle often tests the misconception that fine-tuning is the best way to incorporate domain-specific knowledge, but the trap here is that fine-tuning cannot handle frequently changing data and does not provide source citations, whereas RAG with vector search is purpose-built for dynamic, citation-required use cases.

How to eliminate wrong answers

Option B is wrong because a pre-trained model without customization has no access to the firm's specific internal regulations, leading to hallucinated or outdated answers and no ability to cite sources. Option C is wrong because a rule-based search engine relies on static keyword matching and cannot understand semantic meaning or generate natural language answers, making it unsuitable for complex legal queries and dynamic content. Option D is wrong because fine-tuning on the current regulations would require retraining every quarter when regulations change, which is resource-intensive and does not inherently provide source citation; moreover, fine-tuning risks catastrophic forgetting of prior regulations and cannot dynamically retrieve the latest documents.

Practice this question →
49
MCQeasy

A developer is building a RAG application using OCI Generative AI. They notice that the generated responses often contain outdated information even though the knowledge base is updated daily. What is the most likely cause?

A.The embedding model is not fine-tuned on the latest data.
B.The vector database index is not rebuilt after data updates.
C.The retrieval top-k is set too high.
D.The chunk size is too small, causing loss of context.
AnswerB

If the index is not refreshed, new data is not searchable, leading to outdated results.

Why this answer

In a RAG pipeline, the vector database index is a static snapshot of the embedded knowledge base. When the knowledge base is updated daily, the index must be rebuilt or incrementally updated to reflect the new data. Without rebuilding, the retrieval step will still search the old index, returning outdated chunks and causing the LLM to generate stale responses.

Exam trap

Oracle often tests the misconception that embedding model fine-tuning or chunk size adjustments are the primary cause of outdated responses, when in fact the root cause is the failure to rebuild or update the vector index after data changes.

How to eliminate wrong answers

Option A is wrong because fine-tuning the embedding model on the latest data is not required for RAG; embeddings are typically generated by a pre-trained model and the retrieval quality depends on the index reflecting the current data, not on model fine-tuning. Option C is wrong because setting top-k too high would retrieve more chunks, potentially including irrelevant ones, but it would not cause the responses to contain outdated information—the retrieved chunks would still come from the old index. Option D is wrong because a small chunk size may cause loss of context, leading to incomplete or fragmented answers, but it does not directly cause the use of outdated information; the core issue is the index not being refreshed.

Practice this question →
50
MCQmedium

A developer wants to deploy a RAG application using OCI Generative AI for both embedding and text generation while minimizing costs. Which strategy is most effective?

A.Use a larger generation model
B.Cache frequent queries and their embeddings
C.Reduce chunk size to decrease embedding calls
D.Use a larger embedding model for better accuracy
AnswerB

Caching reduces redundant embedding API calls, lowering costs.

Why this answer

Caching embeddings for frequent queries eliminates repeated embedding API calls, directly reducing cost.

Practice this question →
51
Multi-Selectmedium

Which THREE are valid considerations when designing a RAG pipeline that uses OCI Generative AI and OCI OpenSearch? (Choose three.)

Select 3 answers
A.OCI OpenSearch only supports Euclidean distance for vector similarity.
B.Each document must be converted to a single vector for efficient retrieval.
C.The quality of the text extraction from OCI Document Understanding directly impacts retrieval accuracy.
D.The generation model's context window size limits the number of chunks that can be included in the prompt.
E.The chunk size and overlap must be tuned based on the document type and query patterns.
AnswersC, D, E

Poor extraction leads to noisy embeddings and irrelevant results.

Why this answer

OCI Document Understanding performs text extraction from documents (e.g., PDFs, images). If the extraction is poor (e.g., missing text, OCR errors), the resulting chunks will be inaccurate, directly degrading the quality of vector embeddings and thus retrieval accuracy in the RAG pipeline.

Exam trap

Oracle often tests the misconception that vector databases only support one similarity metric (like Euclidean) or that documents must be stored as single vectors, when in practice they support multiple metrics and chunking is essential for effective retrieval.

Practice this question →
52
MCQhard

A RAG system returns irrelevant chunks even though the embedding model and vector index are correctly configured. After reviewing, the chunks are too large and contain extraneous information. Which combination of adjustments should be made to improve relevance?

A.Increase chunk overlap only.
B.Decrease chunk size and increase chunk overlap.
C.Use semantic chunking and adjust topK.
D.Reduce chunk size, increase overlap, and adjust topK.
AnswerD

All three adjustments can help refine the retrieved context.

Why this answer

Reducing chunk size removes extraneous information, increasing overlap ensures context continuity across smaller chunks, and adjusting topK limits the number of retrieved chunks to the most relevant ones. This combination directly addresses the problem of large chunks containing irrelevant data while maintaining retrieval precision.

Exam trap

Oracle often tests the misconception that only one parameter (like chunk size or topK) needs adjustment, when in reality a combination of chunk size, overlap, and topK tuning is required to address both chunk granularity and retrieval count.

How to eliminate wrong answers

Option A is wrong because increasing chunk overlap alone does not reduce chunk size or remove extraneous information, so irrelevant content persists. Option B is wrong because while decreasing chunk size and increasing overlap helps, it fails to adjust topK, which may still return too many chunks and dilute relevance. Option C is wrong because semantic chunking improves chunk boundaries but does not guarantee smaller chunks or control the number of retrieved chunks; adjusting topK alone without reducing chunk size still allows large chunks with extraneous data.

Practice this question →
53
Multi-Selecteasy

Which TWO of the following are best practices for building a RAG pipeline in OCI?

Select 2 answers
A.Use overlapping chunks
B.Always use exact vector search for accuracy
C.Use a pre-trained embedding model from OCI Generative AI
D.Avoid storing metadata alongside vectors
E.Use a single large chunk for each document
AnswersA, C

Overlapping chunks preserve context across boundaries, improving retrieval.

Why this answer

Overlapping chunks ensure that context is not lost at chunk boundaries, which is critical for retrieval accuracy in RAG pipelines. By including overlapping text segments, the embedding model can capture semantic continuity, reducing the risk of missing relevant information when a query spans chunk edges.

Exam trap

A common misconception in OCI RAG pipelines is that exact vector search is always superior for accuracy. In practice, approximate nearest neighbor (ANN) search in OCI Search with OpenSearch or OCI Generative AI's vector database achieves equivalent recall while being much faster.

Practice this question →
54
MCQhard

A research institution uses OCI Data Flow to process large-scale document corpora for a RAG system. They want to minimize latency for end-user queries. Which architecture decision would most effectively reduce query latency?

A.Embed documents on-the-fly during query time to ensure freshness.
B.Use a larger, more accurate embedding model.
C.Increase the number of Spark workers for parallel processing of queries.
D.Precompute embeddings offline using OCI Data Flow and store them in an OCI OpenSearch index.
AnswerD

Precomputation removes runtime embedding cost.

Why this answer

Precomputing embeddings offline with OCI Data Flow and storing them in an OCI OpenSearch index eliminates the need to generate embeddings at query time, which is the primary source of latency. This approach shifts the computationally expensive embedding generation to a batch process, allowing queries to perform only a fast vector similarity search against the precomputed index, drastically reducing end-user response time.

Exam trap

The trap here is that candidates often confuse batch processing with real-time processing, assuming that more parallelism (Option C) or a better model (Option B) can solve latency issues, when in fact the fundamental latency reduction comes from moving the expensive embedding computation out of the query path entirely.

How to eliminate wrong answers

Option A is wrong because embedding documents on-the-fly during query time introduces significant latency, as the embedding model must process each document in real time, which is impractical for large-scale corpora and defeats the purpose of minimizing query latency. Option B is wrong because using a larger, more accurate embedding model increases the computational cost and time for each embedding generation, which would actually increase latency rather than reduce it, especially if done at query time. Option C is wrong because increasing the number of Spark workers for parallel processing of queries does not address the bottleneck of embedding generation; Spark workers are used for batch processing in OCI Data Flow, not for real-time query serving, and adding more workers would not reduce the latency of the embedding step itself.

Practice this question →
55
MCQhard

A RAG application is hallucinating because the LLM receives irrelevant context from the retrieval step, even when topK is set to 3. Which strategy would best reduce hallucination by improving the relevance of retrieved documents?

A.Reduce the chunk size to one sentence per chunk
B.Add a reranking step after retrieval to select the most relevant chunks
C.Implement a query rewriting mechanism
D.Increase topK to 10 to provide more context
AnswerB

Reranking improves the relevance of the final context set.

Why this answer

Adding a reranking step after retrieval directly addresses the core issue: even with a low topK, the initial retrieval may return chunks that are semantically similar but not precisely relevant to the query. Reranking uses a cross-encoder model to score each retrieved chunk against the query, reordering them so that only the most contextually relevant chunks are passed to the LLM. This reduces the chance of the LLM receiving irrelevant context, thereby minimizing hallucination.

Exam trap

Oracle often tests the misconception that simply adjusting retrieval parameters (like chunk size or topK) can fix relevance issues, when the real solution is a dedicated reranking step that re-evaluates relevance with a more powerful model.

How to eliminate wrong answers

Option A is wrong because reducing chunk size to one sentence per chunk can fragment context and lose necessary supporting information, often making retrieval less coherent and potentially increasing hallucination. Option C is wrong because query rewriting improves the query itself but does not fix the problem of irrelevant chunks already retrieved; it addresses query ambiguity, not retrieval relevance. Option D is wrong because increasing topK to 10 would retrieve more chunks, which could introduce even more irrelevant context and worsen hallucination, not reduce it.

Practice this question →
56
MCQeasy

An organization needs to extract text from PDF documents and convert them into embeddings for a RAG pipeline using OCI. Which OCI service is best suited for extracting text from PDFs?

A.OCI Language
B.OCI Speech
C.OCI Vision
D.OCI Document Understanding
AnswerD

This service provides OCR and text extraction from documents.

Why this answer

OCI Document Understanding is purpose-built for extracting text, tables, and key-value pairs from PDFs and images using pre-trained AI models. It directly supports the text extraction step required to prepare documents for embedding generation in a RAG pipeline, unlike the other services which focus on different modalities or lack native PDF text extraction capabilities.

Exam trap

The trap here is that candidates may confuse OCI Vision's OCR capability with full document text extraction, overlooking that Document Understanding is the dedicated service for extracting structured content from PDFs in a RAG workflow.

How to eliminate wrong answers

Option A is wrong because OCI Language is designed for natural language processing tasks like sentiment analysis and entity extraction, not for extracting raw text from PDF documents. Option B is wrong because OCI Speech is specialized for transcribing audio and speech into text, not for processing PDF files. Option C is wrong because OCI Vision focuses on image analysis (object detection, image classification) and can perform OCR on images, but it is not optimized for extracting structured text from multi-page PDFs, whereas Document Understanding provides a dedicated document parsing pipeline.

Practice this question →
57
MCQhard

A company is deploying a RAG pipeline using OCI Data Science and OCI Generative AI. The pipeline uses a Cohere command model for generation and a Cohere embed model for retrieval. The team notices that the model occasionally produces hallucinated answers that are not supported by the retrieved context. Which strategy is MOST effective at reducing hallucinations?

A.Implement a faithfulness verification step that re-ranks retrieved passages based on alignment with the generated answer.
B.Increase the temperature parameter of the generation model.
C.Increase the number of retrieved chunks (k) to provide more context.
D.Use a larger generative model with more parameters.
AnswerA

Correct. Faithfulness verification re-ranks retrieved passages to align with the generated answer, directly reducing hallucinations by filtering unsupported claims.

Why this answer

Implementing a faithfulness verification step that re-ranks retrieved passages based on alignment with the generated answer directly reduces hallucinations by ensuring the generated output is supported by the retrieved context. Option B is wrong because increasing temperature increases randomness and may lead to more hallucinations. Option C is wrong because increasing the number of retrieved chunks (k) can introduce irrelevant or conflicting information, potentially increasing hallucinations.

Option D is wrong because using a larger generative model does not inherently improve faithfulness to the retrieved context and adds computational cost.

Practice this question →
58
MCQmedium

An organization wants to combine keyword search and vector search to improve retrieval accuracy in their RAG pipeline. Which OCI service provides built-in hybrid search capabilities?

A.OCI Search with AI
B.OCI OpenSearch
C.Autonomous Database with AI Vector Search
D.OCI Logging
AnswerB

OpenSearch integrates BM25 and vector search.

Why this answer

OCI OpenSearch is the correct answer because it natively supports hybrid search, which combines keyword-based (BM25) and vector-based (k-NN) queries in a single search request. This allows the RAG pipeline to retrieve documents that match both exact terms and semantic meaning, improving overall accuracy without requiring separate search systems.

Exam trap

Oracle often tests the misconception that any service with 'AI' or 'Vector' in its name supports hybrid search out of the box, but candidates must recognize that OCI OpenSearch is the only service with a built-in hybrid search pipeline that combines keyword and vector search natively.

How to eliminate wrong answers

Option A is wrong because OCI Search with AI is a managed search service that primarily focuses on AI-powered search over enterprise content, but it does not provide native hybrid search capabilities combining keyword and vector search in a single query. Option C is wrong because Autonomous Database with AI Vector Search supports vector similarity search and SQL-based keyword search, but it requires manual orchestration to combine them into a hybrid search pipeline, lacking built-in hybrid search. Option D is wrong because OCI Logging is a service for collecting and analyzing log data, not a search engine for RAG pipelines, and it has no vector search or hybrid search capabilities.

Practice this question →
59
MCQeasy

A developer wants to build a RAG application that processes highly sensitive medical records. The documents are already stored in OCI Object Storage. Which vector storage strategy best balances security and performance?

A.Store vectors in-memory within the application server
B.Use OCI OpenSearch with a public endpoint for low latency
C.Use OCI OpenSearch with a private subnet and VCN security lists
D.Use a third-party vector database outside OCI
AnswerC

Private subnet ensures network isolation, and security lists control access.

Why this answer

It uses OCI OpenSearch deployed within a private subnet, which ensures that vector data never traverses the public internet, while VCN security lists provide granular traffic control. This architecture balances security (data isolation and access control) with performance (low-latency access within the same VCN or via FastConnect/IPSEC VPN) for sensitive medical records.

Exam trap

The trap here is that candidates may assume a public endpoint is acceptable for 'low latency' (Option B) without recognizing that security requirements for sensitive data override performance considerations, and that private subnet connectivity can still achieve very low latency within the same region.

How to eliminate wrong answers

Option A is wrong because storing vectors in-memory within the application server is volatile, lacks persistence, and cannot scale to handle large document collections, making it unsuitable for production RAG workloads. Option B is wrong because using a public endpoint for OCI OpenSearch exposes the vector store to the internet, violating security requirements for highly sensitive medical records and increasing attack surface. Option D is wrong because using a third-party vector database outside OCI introduces data egress costs, higher latency over the public internet, and compliance risks for sensitive data that should remain within OCI's tenancy.

Practice this question →
60
Multi-Selecthard

Which THREE factors should be considered when designing a vector search index for a RAG application that supports multiple languages?

Select 3 answers
A.Implement language identification as a preprocessing step.
B.Create separate vector indexes for each language.
C.Use a multilingual embedding model that supports all required languages.
D.Configure language-specific text analyzers for preprocessing documents.
E.Use larger chunk sizes for languages with complex morphology.
AnswersA, C, D

Allows proper analyzer selection.

Why this answer

Language identification as a preprocessing step ensures that documents are correctly tagged before indexing, which allows the system to apply appropriate language-specific tokenization, stop-word removal, and stemming. This prevents cross-language contamination in the vector index and improves retrieval accuracy for a multilingual RAG application.

Exam trap

Oracle often tests the misconception that separate indexes per language are required for multilingual support, but the correct approach is to use a single index with a multilingual embedding model and language-specific preprocessing.

Practice this question →
61
MCQmedium

A data scientist is building a RAG application that processes PDF invoices. The extraction step uses OCI Document Understanding to convert PDFs to text. The scientist then splits the text into chunks and generates embeddings using OCI Generative AI. However, the retrieval often misses critical fields like invoice numbers and dates. Which preprocessing step would MOST likely improve retrieval of these specific fields?

A.Increase the chunk size to include entire invoices.
B.Apply stemming and lemmatization to the text before chunking.
C.Tag each chunk with metadata such as invoice number, date, and vendor, and use metadata filtering during retrieval.
D.Switch from dense embeddings to sparse embeddings for better exact match.
AnswerC

Metadata filtering enables precise retrieval based on structured fields.

Why this answer

Metadata tagging and filtering directly address the retrieval of specific fields like invoice numbers and dates. By attaching metadata (e.g., invoice number, date, vendor) to each chunk and filtering on these metadata fields during retrieval, the RAG system can precisely locate the relevant chunks without relying solely on semantic similarity. This approach leverages OCI Document Understanding's ability to extract structured data and OCI Generative AI's vector search capabilities to combine dense embeddings with exact metadata matching.

Exam trap

Oracle often tests the misconception that increasing chunk size or changing embedding type alone can solve retrieval failures for structured fields, when in reality metadata filtering is the correct technique for precise field-level retrieval in RAG applications.

How to eliminate wrong answers

Option A is wrong because increasing chunk size to include entire invoices reduces granularity, making it harder to retrieve specific fields like invoice numbers and dates, and may exceed the context window of the embedding model, degrading retrieval quality. Option B is wrong because stemming and lemmatization reduce words to root forms, which can obscure exact matches for critical fields like invoice numbers (e.g., 'INV-12345' becomes 'inv-12345') and dates (e.g., '2023-01-15' might be altered), harming retrieval precision. Option D is wrong because sparse embeddings (e.g., TF-IDF) improve exact keyword matching but still rely on the text content of chunks; without metadata tagging, the system cannot filter chunks by field type, so critical fields may still be missed if they appear in chunks with low keyword overlap.

Practice this question →
62
MCQeasy

A developer is building a RAG pipeline using OCI Data Science and wants to store vector embeddings. Which OCI service is optimized for vector search and can be used as a vector store?

A.OCI Autonomous Database
B.OCI OpenSearch
C.OCI Object Storage
D.OCI Streaming
AnswerB

OCI OpenSearch includes a vector database plugin for k-NN similarity search, making it a suitable vector store.

Why this answer

B is correct because OCI OpenSearch is a fully managed, search and analytics engine that natively supports k-nearest neighbor (k-NN) search on dense vector embeddings. It provides optimized indexing and querying for high-dimensional vectors, making it the ideal vector store for a RAG pipeline in OCI Data Science.

Exam trap

The trap here is that candidates may confuse OCI Autonomous Database's ability to store vectors with being optimized for vector search, overlooking that OpenSearch is purpose-built for high-performance vector similarity search with native k-NN support.

How to eliminate wrong answers

Option A is wrong because OCI Autonomous Database, while capable of storing vectors, is not optimized for vector search; it lacks native k-NN indexing and relies on SQL-based similarity searches that are less performant for large-scale vector retrieval. Option C is wrong because OCI Object Storage is a blob storage service for unstructured data and does not support vector search operations or indexing. Option D is wrong because OCI Streaming is a real-time data ingestion service for event streams and has no vector storage or search capabilities.

Practice this question →
63
Multi-Selecthard

Which THREE techniques effectively reduce query latency in a RAG system?

Select 3 answers
A.Pre-compute embeddings for all documents
B.Use approximate nearest neighbor search
C.Use a larger generation model
D.Increase the number of shards
E.Use a smaller embedding model
AnswersA, B, E

Pre-computed embeddings avoid real-time embedding calls during query.

Why this answer

Pre-computing embeddings for all documents eliminates the need to generate embeddings at query time, which is a computationally expensive step. By storing pre-computed vector representations, the system can directly perform similarity searches against the index, significantly reducing latency.

Exam trap

Oracle often tests the misconception that increasing model size or shard count always improves performance, but in RAG systems, these changes can introduce latency penalties due to higher computational overhead or distributed coordination costs.

Practice this question →
64
MCQmedium

A financial services company is deploying a RAG system for regulatory compliance queries. The system uses OCI Data Science to run a custom embedding model fine-tuned on regulatory documents. The index in OpenSearch uses cosine similarity and HNSW algorithm. Users report that queries containing synonyms to regulatory terms (e.g., "AML" vs "Anti-Money Laundering") often fail to retrieve relevant documents. Which combination of improvements would be MOST effective? (Assume budget and latency constraints)

A.Increase the `m` parameter in HNSW to improve recall
B.Fine-tune the embedding model further on a dataset of synonyms
C.Implement a hybrid search combining keyword and vector search
D.Use query expansion with a thesaurus before embedding
AnswerC

Hybrid search (BM25 + vector) directly captures exact term matches, bridging the synonym gap effectively.

Why this answer

Hybrid search (combining keyword (BM25) and vector search) catches exact synonym matches from text. Query expansion helps but may not be as reliable. Fine-tuning on synonyms is possible but time-consuming.

Increasing HNSW m slightly improves recall but does not address synonym gap.

Practice this question →
65
MCQmedium

A developer notices that the RAG application returns irrelevant chunks for user queries. The embedding model used is `cohere.embed-english-light-v3.0`. Which action is MOST likely to improve relevance?

A.Reduce the number of retrieved chunks (k)
B.Increase the chunk size
C.Switch to a larger embedding model (e.g., cohere.embed-english-v3.0)
D.Use a different similarity metric (e.g., Euclidean instead of cosine)
AnswerC

Larger models produce higher-quality embeddings, improving retrieval relevance.

Why this answer

The `cohere.embed-english-light-v3.0` model is a smaller, faster embedding model that may lack the semantic richness needed to capture nuanced query-document relationships. Switching to the larger `cohere.embed-english-v3.0` model provides higher-dimensional embeddings with better representational capacity, which directly improves the relevance of retrieved chunks in a RAG pipeline.

Exam trap

Oracle often tests the misconception that tuning retrieval parameters (k, chunk size, similarity metric) can compensate for a weak embedding model, when in fact the embedding quality is the foundational factor for relevance in RAG systems.

How to eliminate wrong answers

Option A is wrong because reducing the number of retrieved chunks (k) does not improve the relevance of each chunk; it merely returns fewer results, potentially missing relevant ones. Option B is wrong because increasing chunk size can dilute semantic focus, making chunks less specific to the query and often reducing relevance. Option D is wrong because cosine similarity is the standard metric for comparing dense embeddings; Euclidean distance is less effective for high-dimensional vectors and would not address the core issue of embedding quality.

Practice this question →
66
MCQeasy

A developer is testing a RAG application using OCI Generative AI. They receive an error: 'The model cohere.command-r-plus-v1:0 is not supported in this region.' What is the most likely cause?

A.The endpoint URL is incorrectly formatted.
B.The model is not available in the selected OCI region.
C.The tenancy is in a different availability domain.
D.The model name has a typo.
AnswerB

Cohere models are deployed in specific regions; the developer may be in a region where the model isn't provisioned.

Why this answer

The error message explicitly states that the model 'cohere.command-r-plus-v1:0' is not supported in the region. OCI Generative AI models are region-specific; each model is deployed only in certain OCI regions (e.g., us-ashburn-1, eu-frankfurt-1). If the selected region does not host that model, the API returns this error regardless of endpoint formatting, tenancy configuration, or model name spelling.

Exam trap

Oracle often tests the misconception that model availability is global across all OCI regions, leading candidates to overlook region-specific model deployment restrictions.

How to eliminate wrong answers

Option A is wrong because an incorrectly formatted endpoint URL would typically produce a 404 Not Found or a connection error, not a model-not-supported error. Option C is wrong because availability domains are a concept for compute instances, not for Generative AI model availability; the error is about regional model support, not AD-level placement. Option D is wrong because a typo in the model name would result in a 'model not found' error (e.g., 400 Bad Request), not a region-specific unsupported error.

Practice this question →
67
MCQhard

An engineer configured the above index mapping for vector search. When performing a k-NN search, the results are unexpected. What is the most likely issue?

A.The space type 'cosinesimil' is not supported; it should be 'cosine'.
B.The dimension 768 does not match the embedding model's output dimension.
C.The mapping uses 'knn_vector' type with 'faiss' engine, which is incompatible.
D.The space type at the index level and mapping level are mismatched.
AnswerD

Mismatch causes incorrect distance calculations.

Why this answer

OpenSearch requires the space type to be consistently defined at both the index-level settings (method.parameters.space_type) and the field-level mapping (space_type). A mismatch between these two causes the k-NN search to behave unexpectedly, as the engine uses the index-level setting for distance computation while the mapping-level setting may be used for validation or other purposes.

Exam trap

Oracle often tests the nuance that OpenSearch requires consistency between index-level and mapping-level space_type settings, a detail that candidates overlook because they assume only the mapping-level setting matters.

How to eliminate wrong answers

Option A is wrong because 'cosinesimil' is a valid space type in OpenSearch (an abbreviation for cosine similarity), not an unsupported value. Option B is wrong because while a dimension mismatch can cause issues, the question states the mapping is configured for vector search and the results are unexpected; the dimension 768 is a common embedding size and is not inherently incorrect without evidence of mismatch. Option C is wrong because 'knn_vector' type with 'faiss' engine is fully compatible and supported in OpenSearch for vector search workloads.

Practice this question →
68
MCQeasy

What is the primary purpose of an embedding model in a RAG pipeline?

A.To convert text into numerical vectors.
B.To generate human-like responses.
C.To rank search results.
D.To summarize long documents.
AnswerA

Embedding models encode text semantically into vectors.

Why this answer

The primary purpose of an embedding model in a RAG pipeline is to convert text into numerical vectors (embeddings) that capture semantic meaning. These vectors enable the retrieval component to efficiently find relevant documents by measuring similarity (e.g., cosine similarity) between the query and stored document embeddings. Without this conversion, the system cannot perform semantic search over unstructured text.

Exam trap

Oracle OCI GenAI exams often test the distinction between the embedding model's role (conversion to vectors) and the LLM's role (generation), so candidates may mistakenly attribute response generation or summarization to the embedding model.

How to eliminate wrong answers

Option B is wrong because generating human-like responses is the role of the large language model (LLM) in the generation step, not the embedding model. Option C is wrong because ranking search results is typically performed by a reranker or the retrieval algorithm (e.g., using vector similarity scores), not by the embedding model itself. Option D is wrong because summarizing long documents is a task for the LLM or a dedicated summarization model, not the embedding model, which only produces vector representations.

Practice this question →
69
MCQeasy

A retail company uses OCI Generative AI Service to build a RAG chatbot for product recommendations. The chatbot should consider both the user's query and the retrieved product descriptions. Which component of the RAG pipeline is responsible for combining these inputs before sending to the LLM?

A.Reranker
B.Document retriever
C.Embedding model
D.Prompt template
AnswerD

Merges user query and context into a single prompt.

Why this answer

The prompt template is the component in a RAG pipeline that structures the final input to the LLM by combining the user's query with the retrieved product descriptions. It defines the format and instructions (e.g., 'Based on these product descriptions, recommend...') that the LLM uses to generate a coherent response. Without a prompt template, the raw query and documents would be sent without context, leading to poor or irrelevant outputs.

Exam trap

Oracle often tests the misconception that the embedding model or retriever handles input combination, when in fact those components only deal with vector representation and retrieval, not prompt assembly.

How to eliminate wrong answers

Option A is wrong because a reranker reorders retrieved documents based on relevance scores after initial retrieval, but it does not combine inputs with the user query for the LLM. Option B is wrong because the document retriever fetches relevant documents from the vector store using similarity search, but it does not merge them with the query into a single prompt. Option C is wrong because the embedding model converts text into vector representations for search, but it plays no role in assembling the final input to the LLM.

Practice this question →

Ready to test yourself?

Try a timed practice session using only Building LLM Applications with RAG and Vector Search questions.

Start 20-question session