1Z0-1127-25 Building LLM Applications with RAG and Vector Search Practice Test 3 — 15 Questions

Question 1

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?

Choose an answer to begin — your selection is scored in the full session.

Accepted Answer

Switch to a larger embedding model (e.g., cohere.embed-english-v3.0). 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.

Answer

Reduce the number of retrieved chunks (k)

Answer

Increase the chunk size

Answer

Use a different similarity metric (e.g., Euclidean instead of cosine)

Question 2

A company uses OCI Data Science to fine-tune an embedding model for a specialized domain. After fine-tuning, the model produces embeddings that are not aligned with the vector index used in OCI OpenSearch. What is the most likely cause?

Accepted Answer

The embedding dimension changed after fine-tuning. Fine-tuning an embedding model can alter the dimensionality of the output embeddings if the model's architecture is modified (e.g., changing the final pooling layer or projection head). OCI OpenSearch vector indexes are built with a fixed dimension; if the fine-tuned model produces embeddings of a different size, they cannot be indexed or queried against the existing index, causing a misalignment. This is the most direct and common cause of such a mismatch.

Answer

The fine-tuning process modified the model architecture

Answer

The fine-tuning dataset was too small

Answer

The vector index was built using a different distance metric than used during fine-tuning

Question 3

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?

Accepted Answer

embed_text. 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.

Answer

generate_embeddings

Answer

encode_text

Answer

create_embedding

Question 4

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?

Accepted Answer

Use a sliding window chunking strategy with overlap. 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.

Answer

Increase the number of retrieved chunks (k)

Answer

Switch to a different embedding model

Answer

Manually rephrase the queries

Question 5

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)

Accepted Answer

Implement a hybrid search combining keyword and vector search. Hybrid search combines lexical keyword matching (BM25) with dense vector similarity, so exact regulatory acronyms like 'AML' match documents even when the embedding model places them far from 'Anti-Money Laundering' in vector space. This directly addresses the synonym gap without retraining the model or changing index parameters, and it stays within typical latency budgets because both retrievers run in parallel and results are fused (e.g., reciprocal rank fusion).

Answer

Increase the `m` parameter in HNSW to improve recall

Answer

Fine-tune the embedding model further on a dataset of synonyms

Answer

Use query expansion with a thesaurus before embedding

Question 6

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)

Accepted Answer

Increase the number of shards from 1 to 10. Increasing shards from 1 to 10 distributes the 5 million vectors across multiple shards, allowing OpenSearch to parallelize the k-NN search across shards and reduce per-query latency while preserving exact k-NN recall. This addresses the single-node/single-shard bottleneck without degrading retrieval quality, unlike switching to approximate search or reducing dimensions. It offers the best latency-versus-quality trade-off among the options.

Answer

Scale OpenSearch cluster to 3 nodes

Answer

Switch to ANN (HNSW with ef_search=50)

Answer

Reduce embedding dimension to 256 using PCA

Question 7

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?

Accepted Answer

The vector search index must have a refresh interval set to immediate.. 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.

Answer

The query should use a hybrid search combining keyword and vector.

Answer

The embeddings must be normalized before indexing.

Answer

The ingestion pipeline should use a text-splitting chunker.

Question 8

A company is deploying a RAG application for legal document analysis using OCI. Which three best practices should be followed to mitigate hallucinations? (Choose 3.)

Accepted Answer

Implement a fallback to abstain from answering if confidence is low.. Option A is correct because implementing an abstention fallback when confidence is low prevents the model from fabricating an answer when the retrieved context does not adequately support one, which is a core hallucination-mitigation pattern in RAG. Option B is correct because a low temperature setting (e.g., near 0) reduces sampling randomness, making the generation model more deterministic and more likely to stay grounded in the retrieved legal text rather than inventing plausible-sounding content. Option C is correct because providing source document citations in the prompt forces the model to ground its output in identifiable passages and enables traceability, which both reduces and helps detect hallucinations in legal analysis. Option D is not among the marked correct answers, so it is not required here; while secondary-model verification can be a valid technique, it is not one of the three best practices selected for this scenario. Option E is not correct because simply increasing retrieved chunks to 10 does not mitigate hallucinations and can even introduce irrelevant context that degrades grounding; retrieval quality and relevance matter more than raw chunk count.

Answer

Include a verification step via a secondary model.

Answer

Increase the number of retrieved chunks to 10.

Question 9

A large organization is deploying a multi-tenant RAG application on OCI, where each tenant has its own set of documents. They use a shared OCI OpenSearch cluster with tenant_id metadata to filter documents. They observe that occasionally, queries from one tenant return results from another tenant's documents. The security team requires strict isolation. They have verified that the metadata filter is correctly applied in the search request. What is the most likely root cause?

Accepted Answer

The tenant_id field is not indexed as a keyword, causing incorrect filtering.. The correct option is B: the tenant_id field is not indexed as a keyword, causing incorrect filtering. In OpenSearch, a text-analyzed field is tokenized and lowercased, so an exact-match filter on a tenant_id value may not match the stored terms reliably, allowing documents from other tenants to pass the filter even though the filter syntax itself is correct. Indexing tenant_id as a keyword preserves the exact value and makes term/terms filters deterministic for strict tenant isolation. Option A is wrong because an unrefreshed index would make recent documents invisible, not return another tenant's documents. Option C is wrong because embedding models do not store or leak per-tenant documents; leakage here comes from filtering, not the model. Option D is wrong because OpenSearch applies filters during the vector search phase (pre-filtering) by default, and post-filtering would reduce recall, not cause cross-tenant matches.

Answer

The OpenSearch index has not been refreshed after ingestion of new documents.

Answer

The embedding model has been trained on data from multiple tenants, causing cross-tenant leakage.

Answer

The metadata filter is being applied after the vector search instead of before.

Question 10

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

Accepted Answer

Enable approximate nearest neighbor (ANN) search for large datasets.. Option C is correct because enabling approximate nearest neighbor (ANN) search (e.g., via the k-NN plugin with HNSW) dramatically reduces query latency and memory cost on large vector datasets, which is essential for a scalable RAG retrieval layer in OCI OpenSearch. Option E is correct because cosine similarity is the standard distance metric for normalized text embeddings, since it measures the angle between vectors and is insensitive to magnitude, giving more reliable semantic similarity for RAG retrieval. Option A is not a best practice per se: embedding dimension is determined by the chosen model (e.g., 1536 for OpenAI text-embedding-ada-002), not arbitrarily increased, and larger dimensions raise storage and compute costs without guaranteed accuracy gains. Option B is wrong because setting index.number_of_replicas to 0 removes redundancy and hurts availability and durability; it is not a recommended production practice. Option D is wrong because storing embeddings in _source bloats the index and slows retrieval; vectors should be stored in dedicated dense_vector/knn_vector fields, with _source excluded or filtered.

Answer

Use a large embedding dimension (e.g., 1536) to improve accuracy.

Answer

Set index.number_of_replicas to 0 to speed up indexing.

Answer

Store the embedding vectors in the _source field to simplify retrieval.

Question 11

Refer to the exhibit. A developer creates an index mapping for a vector search application. When performing a k-NN search query, the query fails with a parsing error. What is the most likely cause?

Accepted Answer

The dimension value 768 does not match the embedding model's output dimension.. The error occurs because the dimension value in the index mapping (768) does not match the actual output dimension of the embedding model used to generate the query vector. In OpenSearch, the k-NN search requires that the dimension of the indexed vectors exactly matches the dimension of the query vector; a mismatch causes a parsing error. Option B correctly identifies this mismatch as the root cause.

Answer

The query is missing the 'knn' query clause.

Answer

The knn setting is not enabled at the index level.

Answer

The space_type should be 'l2' instead of 'cosinesimil'.

Answer

The engine should be 'nmslib' instead of 'faiss'.

Question 12

A company has implemented a RAG-based chatbot using OCI Generative AI and OCI OpenSearch as the vector store. The chatbot answers questions about internal policies. The team uses a dense vector embedding model with 768 dimensions and the HNSW algorithm. The corpus contains 5 million documents. Users report that the chatbot takes 8-12 seconds to respond, and the answers are often not relevant, missing key policy details. Upon investigation, the team finds that the k-NN search returns results based solely on vector similarity, ignoring exact keyword matches that are critical for policy documents. Which course of action will most effectively improve both response time and relevance?

Accepted Answer

Implement hybrid search using a combination of match (keyword) and k-NN (vector) queries with boosting.. Hybrid search combines keyword (match) queries with k-NN vector queries, using boosting to prioritize exact keyword matches for policy documents while still leveraging semantic similarity. This directly addresses the irrelevance issue by ensuring critical policy terms are matched exactly, and the response time improves because the hybrid query can efficiently filter the search space, reducing the number of irrelevant vector comparisons. OCI OpenSearch natively supports this hybrid approach through its query DSL, allowing you to tune the weight of each component.

Answer

Increase the number of OpenSearch data nodes to 5 and use higher-memory instances.

Answer

Reduce the ef_search parameter to 100 and retrain the embedding model on domain-specific data.

Answer

Switch to OCI Generative AI's built-in vector store instead of OpenSearch.

Question 13

You are building a RAG application on OCI Generative AI. Your document corpus is stored in Oracle Autonomous Database 23ai, and you want the LLM to answer questions using only the most relevant passages. You need a serverless, fully managed retrieval approach that avoids provisioning a separate vector database and minimizes operational overhead. What should you use?

Accepted Answer

Oracle Database 23ai vector search with the VECTOR data type and vector indexes, queried through SQL. Oracle Database 23ai includes native vector search capabilities, so embeddings can be stored in a VECTOR column and queried with similarity functions and vector indexes directly in SQL. Because the corpus already resides in Autonomous Database, this avoids standing up another data store, keeps data governance centralized, and provides a managed, serverless experience that aligns with the stated operational constraints.

Answer

OCI OpenSearch with a k-NN index built on the embeddings

Answer

A custom FAISS index hosted on an OCI Compute instance, loaded by the application at runtime

Answer

OCI Generative AI Agents with a knowledge base pointing to the Autonomous Database

Question 14

A financial services firm built a RAG assistant on OCI Generative AI. Documents are chunked into 512-token segments, embedded with an OCI embedding model, and stored in Oracle Database 23ai with a vector index. Users report that answers to questions spanning multiple sections of a 40-page policy document miss key clauses that appear in adjacent chunks. Which change best addresses this retrieval gap?

Accepted Answer

Apply overlapping chunks during ingestion so that content near a boundary appears in more than one chunk, and retrieve the top-k neighbors before passing them to the LLM.. The symptom points to content being split across chunk boundaries during ingestion, so the fix must keep boundary-spanning text retrievable. Overlapping chunks duplicate the boundary region, allowing a clause that straddles two segments to be fully present in at least one vector. Retrieving top-k neighbors then provides the LLM with the adjacent context needed to answer multi-section questions.

Answer

Increase the chunk size to 512 tokens and rely on the embedding model's 512-token context window to capture the full policy section.

Answer

Switch the vector index from Oracle Database 23ai to an approximate nearest neighbor index and increase the number of probes.

Answer

Lower the temperature of the generation model so responses stay closer to the retrieved text and do not drift across sections.

Question 15

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?

Accepted Answer

Adjust the chunk size and chunk overlap to better capture coherent passages.. 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.

Answer

Switch from a dense embedding model to a sparse embedding model.

Answer

Increase the chunk size to capture more context.

Answer

Reduce the number of retrieved chunks (k) in the vector search.