1Z0-1127-25 Exam Questions and Answers

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?

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

Adjust the chunk size and chunk overlap to better capture coherent passages.

Chunk size and overlap determine whether each embedding captures a coherent passage; poorly sized chunks split context, producing vectors that match unrelated queries. Tuning these parameters improves semantic alignment between chunks and queries, addressing the retrieval relevance problem.

Increase the chunk size to capture more context.

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

Why: 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.

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?

Create an ANN index on the embedding vector column.

An approximate nearest neighbour index on the embedding vector column enables fast similarity search across large document sets, avoiding exhaustive comparisons. This satisfies the requirement for efficient retrieval of the most relevant documents by user query.

Create a bitmap index on the embedding vector column.

Create an inverted index on the document text column.

Create a B-tree index on the document text column.

Why: 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.

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?

Increase the chunk size to include entire invoices.

Apply stemming and lemmatization to the text before chunking.

Tag each chunk with metadata such as invoice number, date, and vendor, and use metadata filtering during retrieval.

Invoice numbers and dates are structured fields that semantic similarity alone retrieves poorly, since chunk embeddings blur exact tokens. Tagging each chunk with extracted metadata and applying metadata filters during retrieval lets the query constrain candidates to matching invoice numbers, dates or vendors, directly satisfying the need to surface these critical fields.

Switch from dense embeddings to sparse embeddings for better exact match.

Why: 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.

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?

Deploy the generative AI model endpoints within the same OCI region as the data and compute.

Data residency requires that processing, not merely storage, stays inside the specified region. Hosting the OCI Generative AI model endpoints in the same OCI region as the data and OCI Data Science compute ensures prompts, embeddings and outputs never cross regional boundaries, satisfying the stem's residency constraint.

Use OCI Generative AI endpoints in a different region but store data in the required region.

Use an external third-party LLM endpoint that guarantees data residency.

Store embeddings in a different region but run inference in the required region.

Why: 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.

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?

Decrease the chunk size to focus on smaller units.

Increase the number of retrieved chunks to cover more variations.

Use a spell-checker on the retrieved chunks.

Implement query rewriting or expansion using a language model before embedding.

Typos and abbreviations produce embeddings that drift from the indexed chunks, so similarity search misses relevant passages. Rewriting or expanding the query with a language model normalises spelling and resolves abbreviations into canonical terms before embedding, restoring lexical and semantic overlap with the corpus.

Why: 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.

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

Use a vector database such as OCI OpenSearch with ANN indexes for storing embeddings.

Storing embeddings in OCI OpenSearch with approximate nearest neighbour indexes makes similarity search scale to large corpora, returning nearest chunks in sub-linear time rather than exhaustive comparison. This is the standard retrieval backbone for OCI RAG pipelines, keeping latency acceptable as document volume grows.

Generate embeddings for documents at query time to ensure freshness.

Pre-index the documents and update the index periodically to reflect new content.

Pre-indexing documents and refreshing the index periodically keeps retrieval aligned with current content without rebuilding embeddings per query. Stale indexes return outdated chunks, so scheduled updates ensure newly added or revised documents remain retrievable, which is a core operational practise for production RAG on OCI.

Store the source documents only in OCI Object Storage and retrieve them at query time using full-text search.

Use a different embedding model for documents and queries to capture distinct semantics.

Why: Option A is correct because a RAG application needs an efficient similarity-search layer for embeddings, and OCI OpenSearch supports vector fields with approximate nearest neighbor (ANN) indexes (e.g., HNSW or IVF) to retrieve the top-k most semantically similar chunks quickly at scale. Option C is correct because best practice is to pre-index document chunks and their embeddings ahead of time, then refresh the index periodically (or incrementally) as new content arrives, so query-time latency stays low while the knowledge base remains reasonably current. Option B is wrong because generating embeddings for all documents at query time is prohibitively expensive and slow; embeddings should be computed once at ingestion/indexing time, with only the user query embedded at query time. Option D is wrong because storing documents only in Object Storage and doing full-text search at query time does not provide semantic vector retrieval, which is the core of RAG. Option E is wrong because documents and queries must be embedded with the same embedding model so their vectors live in the same semantic space and cosine/dot-product similarity is meaningful.

Want more Building LLM Applications with RAG and Vector Search practice?

All Fundamentals of Large Language Models questions

Domain 2: Fundamentals of Large Language Models

12% of exam · 6 sample questions below

A company is deploying a large language model for a customer service chatbot. The model needs to understand industry-specific jargon and maintain low latency. Which approach best balances these requirements?

Employ retrieval-augmented generation (RAG) with a general model

Rely solely on prompt engineering with a general model

Use a large general-purpose LLM with zero-shot prompting

Fine-tune a small open-source LLM on domain-specific data

Fine-tuning a small open-source model on domain data teaches industry jargon through weight updates while keeping inference cheap and fast. A smaller model serves responses with lower latency than a large general-purpose LLM, satisfying both the terminology and latency constraints.

Why: Fine-tuning a small open-source LLM on domain-specific data is the best approach because it adapts the model to understand industry-specific jargon while keeping the model small enough to maintain low latency. Unlike larger models, a fine-tuned small model can run efficiently on local hardware, reducing inference time and avoiding the overhead of external API calls or large model sizes.

A data scientist observes that their fine-tuned LLM performs well on training data but generates repetitive and dull responses in production. What is the most likely cause and best solution?

The model is overfitted; apply stronger regularization

The temperature is set too low; increase temperature during inference

Low temperature sharpens the softmax distribution, so the model repeatedly selects high-probability tokens, producing repetitive, dull output. Raising temperature during inference flattens that distribution, increasing token diversity. This directly addresses the production-only symptom: the model generalises fine, so the fault lies in decoding, not training.

The training data lacks diversity; add more varied examples

The model has too many layers; reduce model size

Why: The model's repetitive and dull responses indicate that the temperature parameter is too low, causing the model to always select the most probable tokens, leading to deterministic and monotonous outputs. Increasing temperature during inference introduces randomness into token sampling, allowing for more diverse and creative responses. This is a common issue in production LLMs where low temperature settings optimized for training metrics fail to produce engaging real-world outputs.

An organization wants to use an LLM to summarize legal documents. Which consideration is most important for ensuring accurate summaries?

Fine-tune the model on a curated legal corpus

Fine-tuning on a curated legal corpus adapts the model's weights to domain terminology, citation conventions and reasoning patterns, improving factual fidelity for legal text. This satisfies the accuracy requirement more directly than prompt engineering alone, which cannot instil specialised legal knowledge.

Use the largest available general-purpose model

Rely on zero-shot summarization with careful prompting

Pre-train a new model from scratch on legal texts

Why: Fine-tuning on a curated legal corpus is the most important consideration because legal summarization demands domain-specific terminology, citation conventions, and reasoning patterns that general-purpose models often mishandle. Fine-tuning adapts the model's weights to legal language, improving factual fidelity and reducing hallucinations on statutes, case law, and contracts. While prompting and model size help, domain adaptation is the decisive factor for accuracy in a specialized field.

A developer is building a code generation assistant. The model occasionally produces syntactically correct but semantically wrong code. Which technique directly addresses semantic correctness?

Expand the token vocabulary

Lower the temperature to 0

Apply RLHF using human-validated code examples

RLHF with human-validated code examples optimises the model against human judgements of correctness, not just syntax, directly targeting the semantic errors described. This addresses the stem's requirement that generated code be semantically, not merely syntactically, correct.

Increase beam search width

Why: Reinforcement Learning from Human Feedback (RLHF) directly addresses semantic correctness by fine-tuning the model using human-validated code examples. This process teaches the model to prefer outputs that are not only syntactically valid but also logically correct and aligned with developer intent, reducing semantically wrong code generation.

A company fine-tunes an LLM on internal support tickets. After deployment, the model hallucinates company-specific product names. What is the most effective mitigation?

Switch to a smaller model to reduce hallucination risk

Use prompt engineering to remind the model to be accurate

Implement RAG with a verified product database

RAG retrieves verified product names from the database at inference time and injects them into the prompt, grounding generation in authoritative facts rather than relying on weights that may have absorbed incorrect ticket text. This directly prevents hallucinated product names without retraining the fine-tuned model.

Fine-tune further with more ticket data

Why: RAG (Retrieval-Augmented Generation) grounds the LLM's output in a verified product database, providing factual context that prevents hallucination of company-specific product names. Unlike fine-tuning, which only adjusts model weights and can still produce plausible but incorrect names, RAG retrieves exact records at inference time, ensuring accuracy for proprietary terminology.

A team wants to evaluate an LLM's performance on a text classification task. Which metric is most appropriate for a balanced dataset?

BLEU score

Perplexity

Accuracy

Accuracy divides correct predictions by total predictions, giving a directly interpretable score. On a balanced dataset each class contributes equally, so accuracy is not skewed by majority-class dominance, satisfying the stem's balanced-data constraint without needing precision, recall or F1.

ROUGE score

Why: Accuracy is the most appropriate metric for evaluating an LLM on a text classification task with a balanced dataset because it directly measures the proportion of correctly predicted labels out of total predictions. For balanced classes, accuracy provides a reliable and intuitive performance indicator without the distortion caused by class imbalance.

Want more Fundamentals of Large Language Models practice?

All Prompt Engineering questions

Domain 3: Prompt Engineering

13% of exam · 6 sample questions below

A data scientist is designing a prompt to generate a structured report with sections for Summary, Findings, and Recommendations. Which output format specification in the prompt would be MOST effective?

"Write a report with three sections: Summary, Findings, Recommendations."

"Provide the output in JSON format with keys: 'summary', 'findings', and 'recommendations'."

JSON enforces explicit key-value pairs, so the model must populate 'summary', 'findings', and 'recommendations' as discrete fields rather than free prose. This directly satisfies the stem's requirement for a structured report with three defined sections, giving deterministic, machine-parseable output that plain text or Markdown headings cannot guarantee.

"Return the report in bullet points."

"Output the report as a markdown document with headings."

Why: Specifying JSON with explicit keys ('summary', 'findings', 'recommendations') gives the model an unambiguous, machine-parseable schema that enforces the exact three-section structure. This is the most effective format specification because it constrains the output to a deterministic structure that downstream code can consume directly, eliminating ambiguity about section names or ordering.

A developer notices that a Cohere Command model occasionally generates contradictory statements in the same response when asked to reason step-by-step. Which technique is designed to address inconsistency by generating multiple reasoning paths and selecting the most consistent answer?

Few-shot prompting

Temperature tuning

Tree-of-thought prompting

Self-consistency

Self-consistency samples multiple diverse reasoning chains from the model and aggregates their final answers, typically by majority vote, selecting the most frequently reached conclusion. This reduces contradictions arising from any single flawed chain, directly addressing the inconsistent step-by-step reasoning described.

Why: Self-consistency is a technique specifically designed to address inconsistency in model outputs by sampling multiple reasoning paths (e.g., via chain-of-thought) and then selecting the most consistent answer through majority voting or similar aggregation. This directly targets the problem of contradictory statements within a single response by leveraging the model's own diverse reasoning trajectories to converge on a reliable answer.

Which parameter controls the creativity and randomness of a model's output by adjusting the probability distribution before sampling the next token?

Frequency penalty

Max tokens

Temperature

Temperature scales the logits before the softmax, flattening or sharpening the probability distribution prior to sampling the next token. Lower values make output more deterministic; higher values increase randomness and creativity, directly controlling the diversity of generated text.

Top-k

Why: Temperature scales the logits (pre-softmax scores) before sampling, flattening or sharpening the probability distribution. Lower values make output more deterministic; higher values increase randomness and creativity.

An engineer is using the ReAct pattern to build a reasoning agent. The agent should first reason about the user query, then call an external API, and finally incorporate the API result into a final answer. Which prompt structure best implements this pattern?

"You have access to an API. For each step, output 'Thought:', then 'Action:', then 'Observation:' before the final answer."

The ReAct pattern interleaves reasoning and acting, so the prompt must expose explicit Thought, Action and Observation steps. This structure lets the agent reason, invoke the external API, then fold the returned observation into its final answer, matching the stem's required sequence.

"You are a helpful assistant. Answer the user's question based on your knowledge."

"First, call the API. Then, output the result."

"Think step by step, then provide the final answer."

Why: The ReAct pattern interleaves reasoning and acting: the model emits a Thought, then an Action (e.g., an API call), then receives an Observation, and repeats until it can produce a final answer. Option A explicitly structures the prompt with 'Thought:', 'Action:', and 'Observation:' tokens, which is the canonical ReAct format and directly supports the reason → call API → incorporate result flow described in the question.

A prompt engineer is tasked with reducing hallucinations in a document-grounded generation task using Cohere Command R. Which system prompt component is MOST effective for enforcing that the model only uses provided documents?

"You are an expert in the field. Use your extensive knowledge to answer."

"Provide a detailed answer with references."

"Use a temperature of 0.0 for factual answers."

"Answer the question based solely on the provided document. If the document does not contain the answer, say 'I don't know'."

An explicit grounding constraint plus a refusal fallback directly suppresses pre-trained knowledge leakage: instructing the model to answer solely from the supplied document and to return "I don't know" when the answer is absent removes the incentive to hallucinate, satisfying the stem's document-grounded requirement.

Why: It explicitly instructs the model to ground its response solely in the provided documents and to acknowledge uncertainty ('I don't know') when the answer is absent. This directly addresses the root cause of hallucinations in RAG-style tasks: the model drawing on parametric knowledge instead of the retrieved context. Cohere Command R is specifically designed for RAG with citation grounding, and this instruction reinforces that behavior.

In few-shot prompting, what is the primary purpose of including examples in the prompt?

To reduce the need for a system prompt

To provide a template for the desired output format and reasoning pattern

Including examples demonstrates the expected output structure and reasoning style, letting the model infer the task pattern from context rather than explicit instructions. This satisfies few-shot prompting's core constraint: guiding behaviour through in-context demonstration, which is precisely how the technique conditions responses without weight updates.

To increase the model's vocabulary

To decrease the computational cost of inference

Why: Examples guide the model on the desired input-output pattern, improving task performance without fine-tuning.

Want more Prompt Engineering practice?

All Deploying and Managing Generative AI on OCI questions

Domain 4: Deploying and Managing Generative AI on OCI

12% of exam · 6 sample questions below

A company is deploying a generative AI service on OCI using the OCI Data Science service with a large language model (LLM) in a VCN. The model inference endpoint must be accessible only from a private subnet within the same VCN. Which networking component should be configured to enable this?

NAT Gateway

Dynamic Routing Gateway (DRG)

Internet Gateway

Service Gateway

Service gateway enables private subnet access to OCI services like Data Science.

Why: A Service Gateway enables private subnet resources to access OCI services (including the OCI Data Science model deployment endpoint) without traversing the internet. Since the inference endpoint must be accessible only from a private subnet within the same VCN, the Service Gateway provides the necessary private connectivity by routing traffic over the OCI network fabric, not through a NAT or internet gateway.

A company is using OCI Generative AI service with a dedicated AI cluster for text generation. They notice that the latency is higher than expected. The cluster is in the Ashburn region, and users are distributed globally. What is the most effective way to reduce latency?

Enable the OCI Generative AI inference optimizer

Deploy dedicated AI clusters in regions closer to the users

Latency is dominated by physical distance between users and the inference endpoint. Deploying dedicated AI clusters in regions nearer those users shortens network round-trip time, which is more effective than tuning the model or increasing cluster capacity in Ashburn.

Increase the number of nodes in the dedicated AI cluster

Use a content delivery network (CDN) to cache responses

Why: Latency for globally distributed users is primarily driven by network distance and the speed of light. Deploying dedicated AI clusters in regions closer to the users reduces the physical distance data must travel, directly minimizing network round-trip time (RTT). This is the most effective architectural change because OCI's Generative AI service processes each request on the dedicated cluster and cannot bypass geographic latency through software optimizations alone.

A developer wants to call the OCI Generative AI service from a Python application running on an OCI Compute instance. Which method is the most secure for authenticating the API calls?

Use a resource principal

Use the OCI CLI with a config file containing credentials

Use instance principals with a dynamic group and policy

Instance principals let the compute instance authenticate through its dynamic group membership, so no API keys or credentials are stored on the instance. A policy then authorises that dynamic group to call the Generative AI service, eliminating long-lived secrets that could be exfiltrated.

Use an API signing key stored on the instance

Why: Instance principals allow the Compute instance to authenticate to OCI services without storing any credentials on the instance. By assigning a dynamic group and policy, the instance obtains a temporary security token from the OCI metadata service, which is the most secure method for programmatic access from within OCI.

Which THREE components are required to deploy a custom generative AI model on OCI Data Science model deployment?

A load balancer to distribute traffic

An inference script (e.g., score.py) to handle prediction requests

OCI Data Science model deployment requires an inference script defining the predict function that loads the model and transforms incoming request payloads into responses. Without it, the deployment runtime cannot serve prediction requests, so the endpoint fails to initialise.

A model artifact containing the model files

The model artifact packages the serialised model files, weights and dependencies that the deployment loads at runtime. OCI Data Science cannot instantiate the model without this artifact, making it a mandatory component alongside the inference script and deployment configuration.

An API signing key for authentication

A deployment configuration specifying resources and environment

The deployment configuration specifies the compute shape, instance count, bandwidth and environment variables the endpoint uses. OCI Data Science needs these resource parameters to provision and scale the inference container, so deployment cannot proceed without it.

Why: Option B is correct because OCI Data Science model deployments require an inference script such as score.py that defines the predict function and handles incoming prediction requests through the model artifact's runtime. Option C is correct because the model artifact (a ZIP or folder containing the serialized model files, dependencies, and the inference script) is the packaged unit that OCI Data Science deploys and serves. Option E is correct because a deployment configuration is required to specify the shape/resources (for example, VM.Standard.E4.Flex with a given OCPU and memory), the environment (conda environment or container image), and other runtime settings for the deployment. Option A is not required because OCI Data Science model deployment provisions its own managed endpoint and load balancing internally, so the user does not supply a load balancer. Option D is not required because authentication to the deployment endpoint is handled through OCI IAM policies, resource principals, or auth tokens, not through an API signing key configured as a deployment component.

Which TWO are valid methods to monitor the performance of a generative AI model deployed on OCI Data Science?

Use OCI Notifications to receive alerts on model drift

Use OCI Monitoring service to track custom metrics like latency and throughput

OCI Monitoring ingests custom metrics emitted by the model endpoint, letting you chart latency and throughput against thresholds and trigger alarms. This directly satisfies the stem's requirement to monitor deployed generative AI performance continuously rather than only reviewing logs after the fact.

Use OCI Logging service to collect inference logs

OCI Logging captures the inference request and response records produced by the deployed model, giving an auditable trail for diagnosing errors and usage patterns. It complements metric-based monitoring by satisfying the stem's need to observe individual predictions rather than only aggregate performance figures.

Use OCI Events service to trigger retraining on low accuracy

Use OCI Audit service to review API call logs

Why: Option B is correct because OCI Monitoring supports custom metrics, so you can publish model-specific metrics such as inference latency and throughput via the Monitoring API/CLI and build alarms on them. Option C is correct because OCI Logging can collect and store inference logs (e.g., via the Logging service and agents or the Logging API), which lets you inspect request/response data and analyze model behavior over time. Option A is not a monitoring method per se: OCI Notifications only delivers messages/alerts that must first be triggered by an alarm or event, and it does not itself detect model drift. Option D is not a valid monitoring method: OCI Events reacts to state changes in OCI resources, not to model accuracy metrics, so it cannot trigger retraining on low accuracy by itself. Option E is not a monitoring method for model performance: OCI Audit records control-plane/API activity for compliance and security, not inference latency, throughput, or model quality.

An administrator runs the above CLI command to check the status of a dedicated AI cluster. The cluster is ACTIVE with capacity 10. However, a user reports that inference requests to this cluster are failing with a '429 Too Many Requests' error. What is the most likely cause?

The cluster is hitting the maximum inference requests per minute limit

A 429 response is a throttling signal, not a capacity or health failure. Since the cluster is ACTIVE with capacity 10, the requests are exceeding the configured inference requests per minute ceiling. Raising that limit, or reducing call frequency, resolves the failures.

The cluster does not have enough nodes to handle the load

The user is not in the same compartment as the cluster

The cluster is not in ACTIVE state

Why: The '429 Too Many Requests' error is an HTTP status code indicating rate limiting has been exceeded. In OCI Generative AI, dedicated AI clusters have a configurable 'maximum inference requests per minute' limit. Even if the cluster is ACTIVE and has capacity (e.g., 10 nodes), hitting this per-minute request cap will cause the API gateway to reject further requests with a 429 error. The administrator must increase the rate limit or implement client-side throttling to resolve this.

Want more Deploying and Managing Generative AI on OCI practice?

All OCI Generative AI Service questions

Domain 5: OCI Generative AI Service

13% of exam · 6 sample questions below

You need to convert a set of customer support tickets into vector embeddings for a similarity search application. Which OCI Generative AI model should you use?

Cohere Rerank

Cohere Embed (e.g., embed-english-v3.0)

Cohere Embed models are purpose-built text embedding models on OCI Generative AI, converting support tickets into dense vectors for similarity search. This satisfies the stem's constraint of generating vector embeddings, unlike generation models such as Cohere Command or Llama, which produce text rather than embeddings.

Meta Llama 3

Cohere Command R

Why: Cohere Embed models (such as embed-english-v3.0) are specifically designed to generate vector embeddings from text for semantic search, clustering, and classification. Converting support tickets into embeddings for similarity search is exactly the use case for an embedding model. OCI Generative AI offers Cohere Embed as a managed embedding service.

A developer is using the OCI Generative AI Chat API with Cohere Command R+ to build a multi-turn conversational agent. They want the agent to always respond in a formal tone, regardless of the user's phrasing. Which parameter should they set in the API request to achieve this consistently?

Set the 'stop_sequences' parameter to include periods

Set the 'temperature' parameter to 0.1

Use the 'system' parameter (or preamble_override) to provide a system message like 'You are a formal assistant'

The system parameter (or preamble_override) injects a persistent instruction before the conversation, shaping tone across all turns. Setting it to 'You are a formal assistant' enforces formal responses regardless of user phrasing, satisfying the consistent-tone requirement.

Set the 'max_tokens' parameter to 200

Why: A system message or preamble override sets the overall behavior and tone of the assistant for the entire conversation. Temperature controls randomness; max tokens limits length; stop sequences end generation — none are suitable for defining a persistent tone.

A company uses OCI Generative AI Agents to build a RAG application that answers questions from documents stored in OCI Object Storage. The knowledge base is updated daily. Which step is necessary to ensure the agent incorporates the latest documents?

Re-sync the knowledge base after updating the documents in Object Storage

The knowledge base indexes a snapshot of the Object Storage data, so newly added or changed documents are invisible until ingestion runs again. Re-syncing after each daily update refreshes the index, ensuring the agent retrieves the latest documents.

Use the Embedding API to manually index each new document

Set the session API to refresh automatically

Recreate the agent each time documents change

Why: The knowledge base indexes the data sources. To reflect changes in the source documents, you must re-sync or re-index the knowledge base. The agent endpoint or session API does not automatically refresh content.

You want to test different prompts and parameters (temperature, max tokens) for a summarization task using a foundation model without writing any code. Which OCI tool should you use?

OCI Console -> Generative AI -> Models

OCI Generative AI Playground

The OCI Generative AI Playground provides a no-code console interface for experimenting with prompts and parameters such as temperature and max tokens against foundation models. This satisfies the requirement to test summarisation prompts without writing code.

OCI CLI with the 'oci generative-ai' commands

Python SDK with InferenceClient

Why: The OCI Generative AI Playground provides an interactive UI to experiment with models and parameters. CLI, SDK, and console navigation are not for interactive experimentation.

A team is fine-tuning a Llama 3 model using OCI Generative AI. The training dataset contains 10,000 prompt-completion pairs in JSONL format. After submitting the fine-tuning job, it fails with a 'Data validation error'. What is the most likely cause?

The base model selected does not support fine-tuning

The dataset is in the wrong compartment

The fine-tuning job does not have enough model units allocated

The JSONL file uses 'input' and 'output' as key names instead of 'prompt' and 'completion'

OCI Generative AI fine-tuning expects JSONL records keyed as 'prompt' and 'completion'. Supplying 'input' and 'output' instead means the required fields are absent, so schema validation rejects the dataset before training begins, producing the reported data validation error.

Why: OCI fine-tuning requires a specific JSONL format with 'prompt' and 'completion' keys. If the keys are named differently (e.g., 'input'/'output'), validation fails. Model units, compartment, and base model are not typically validation issues.

An application needs to generate embeddings for text in multiple languages (English, Spanish, French). Which OCI Generative AI embedding model should be used?

embed-english-v3.0

Cohere Command R

embed-multilingual-v3.0

embed-multilingual-v3.0 maps English, Spanish and French text into one shared vector space, so semantically equivalent phrases across languages land close together. That cross-lingual alignment satisfies the stem's multilingual requirement, which a monolingual English-only embedding model cannot deliver regardless of dimension or context length.

Meta Llama 3

Why: The OCI Generative AI embedding model embed-multilingual-v3.0 is specifically designed to generate embeddings for text in multiple languages, including English, Spanish, and French. It supports over 100 languages and is optimized for cross-lingual tasks, making it the correct choice for multilingual embedding needs.

Want more OCI Generative AI Service practice?

All LLM Fundamentals questions

Domain 6: LLM Fundamentals

13% of exam · 6 sample questions below

What is the primary purpose of the self-attention mechanism in a Transformer model?

To generate token embeddings in parallel

To reduce the dimensionality of token embeddings

To encode positional information of tokens

To compute a weighted sum of all token representations based on pairwise relevance

Self-attention projects each token into query, key and value vectors, then computes pairwise relevance scores whose softmax weights produce a weighted sum of all token representations, giving every position direct contextual access regardless of distance.

Why: Self-attention allows each token to attend to every other token in the sequence, capturing contextual relationships regardless of distance.

Which of the following best describes the difference between an encoder-only model (e.g., BERT) and a decoder-only model (e.g., GPT)?

Encoder-only uses bidirectional attention and is suited for classification or NER; decoder-only uses causal attention and is suited for text generation

Encoder-only architectures apply bidirectional self-attention, letting each token attend to all others, which suits classification and NER. Decoder-only architectures apply causal masking so tokens attend only to prior tokens, enabling autoregressive text generation. This attention-direction difference is the defining architectural distinction.

Encoder-only is trained for text generation; decoder-only is trained for classification

Both use the same attention pattern but differ in number of layers

Encoder-only uses causal attention; decoder-only uses bidirectional attention

Why: Encoder-only models like BERT employ bidirectional attention, allowing each token to attend to all other tokens in both directions, which is ideal for tasks requiring full context understanding such as classification or named entity recognition (NER). In contrast, decoder-only models like GPT use causal (masked) attention, where each token can only attend to previous tokens, making them suitable for autoregressive text generation.

A practitioner wants to evaluate an LLM-generated summary against a human-written reference using a metric that focuses on recall of key information. Which metric is most appropriate?

BLEU

Perplexity

Cosine similarity

ROUGE

ROUGE measures n-gram overlap between generated and reference summaries, with recall-oriented variants such as ROUGE-L and ROUGE-N counting how much reference content the candidate captures. This directly satisfies the stem's requirement to focus on recall of key information against a human-written reference.

Why: ROUGE (Recall-Oriented Understudy for Gisting Evaluation) is the most appropriate metric because it specifically measures recall of key information by comparing n-gram overlap between the generated summary and a reference summary. This aligns directly with the practitioner's goal of evaluating how well the LLM-generated summary captures the essential content from the human-written reference.

A company needs to generate embeddings for a large corpus of legal documents to enable semantic search. Which type of model should they use?

An encoder-only embedding model like Cohere Embed

Encoder-only models map text into dense vector embeddings, which is exactly what semantic search requires for similarity comparison. Cohere Embed produces these vectors without generating text, matching the legal corpus embedding task rather than a generation workload.

A decoder-only generation model like GPT

A text-to-speech model

A machine translation model

Why: An encoder-only embedding model like Cohere Embed is designed to convert text into dense vector representations (embeddings) that capture semantic meaning, which is exactly what is needed for semantic search over a large corpus of legal documents. These models use a bidirectional transformer architecture to encode context from both directions, producing fixed-size embeddings that can be efficiently compared using cosine similarity or other distance metrics.

Which of the following sampling strategies selects tokens based on a cumulative probability threshold from the highest probability tokens?

Top-p (nucleus) sampling

Top-p sampling sorts tokens by probability, sums them cumulatively, and retains the smallest set whose cumulative probability reaches the threshold p; sampling then occurs within that nucleus. This directly matches the stem's cumulative probability threshold criterion, unlike top-k's fixed token count.

Top-k sampling

Greedy decoding

Temperature sampling

Why: Top-p (nucleus) sampling cuts off the tail of the probability distribution where cumulative probability exceeds p, allowing dynamic vocabulary size.

An OCI Generative AI practitioner observes that a Cohere Command model generates responses with outdated information about a recent event. The model was fine-tuned six months ago. Which technique should be applied to incorporate new knowledge without retraining the model?

Use a longer context window and include all new articles in the prompt

Fine-tune the model again with the new data

Implement a RAG pipeline that indexes the latest documents into a vector store and retrieves relevant passages at query time

Retrieval-augmented generation retrieves relevant passages from a vector store of freshly indexed documents and supplies them as context at query time. This injects current knowledge without retraining or fine-tuning, satisfying the requirement to avoid model retraining.

Increase the temperature parameter to encourage more creative outputs

Why: RAG (Retrieval-Augmented Generation) lets you inject new knowledge at query time without retraining: you index the latest documents into a vector store, retrieve the most relevant passages for the user's query, and pass them as context to the model. This keeps the base model frozen while grounding responses in current information, which is exactly the requirement.

Want more LLM Fundamentals practice?

All LangChain and AI Application Development questions

Domain 7: LangChain and AI Application Development

13% of exam · 6 sample questions below

In LangChain, which component is responsible for connecting a language model to a retriever and a prompt template to answer questions based on retrieved documents?

RetrievalQA chain

The RetrievalQA chain wires a retriever and a prompt template to a language model, fetching relevant documents and feeding them into the prompt for grounded answers. This satisfies the stem's requirement to answer questions from retrieved documents.

LLMChain

SequentialChain

AgentExecutor

Why: RetrievalQA is the LangChain chain purpose-built to wire together a retriever, a prompt template, and an LLM so the model answers questions grounded in retrieved documents. It handles the retrieve-then-generate flow automatically: it fetches relevant chunks from the vector store, injects them into the prompt, and passes the augmented prompt to the LLM. This is the classic RAG pattern in LangChain.

A developer is building a RAG pipeline using LangChain and Oracle AI Vector Search. After loading and splitting PDF documents, they generate embeddings and store them in Oracle Database using OracleVS. Which method should they call on the vector store object to create a retriever that uses similarity search with a configurable number of results?

as_retriever()

Calling `as_retriever()` on the OracleVS vector store returns a VectorStoreRetriever, which performs similarity search against Oracle AI Vector Search. Passing `search_kwargs={"k": n}` satisfies the stem's requirement for a configurable number of results, unlike direct `similarity_search()` calls that return a fixed count.

from_texts()

max_marginal_relevance_search()

similarity_search()

Why: The as_retriever() method on a LangChain vector store object (including OracleVS) returns a VectorStoreRetriever that integrates with the LangChain chain interface. It accepts a search_kwargs dictionary where you can specify 'k' to control the number of results returned by similarity search. This is the standard LangChain pattern for converting a vector store into a retriever component for RAG pipelines.

A company uses LangChain with OCI Generative AI. They notice that their agent-based application occasionally exceeds the rate limits of the OCI Generative AI service, causing errors. Which strategy is MOST effective for handling rate limits in a production LangChain application?

Implement a retry mechanism with exponential backoff when calling the model

Exponential backoff retries the model call after progressively longer delays, spreading requests so the application recovers from OCI Generative AI throttling without hammering the service. This directly addresses the intermittent rate-limit errors described, making it the most effective production strategy.

Increase the k value in the retriever to reduce the number of API calls

Switch to a smaller model to reduce token consumption

Reduce the chunk_size parameter in text splitters

Why: Exponential backoff with retry is the canonical, production-grade pattern for handling HTTP 429/rate-limit responses from OCI Generative AI. When the service throttles a request, the client waits an increasing interval (e.g., 1s, 2s, 4s, 8s with jitter) before retrying, giving the token bucket time to refill and preventing a thundering-herd effect. LangChain exposes this via the `max_retries` parameter on ChatOCIGenAI/OCIGenAI LLM wrappers, which internally uses exponential backoff. This directly addresses the transient nature of rate-limit errors without degrading retrieval quality or model capability.

Which LangChain memory type stores the entire conversation history as a list of messages and is best for simple, short conversations?

ConversationTokenBufferMemory

ConversationSummaryMemory

ConversationBufferMemory

ConversationBufferMemory retains every user and AI message verbatim in an in-memory list, passing the complete history to the model each turn. This unbounded retention suits short, simple conversations where full context matters more than token efficiency.

ConversationBufferWindowMemory

Why: ConversationBufferMemory stores the entire conversation history as a list of messages and passes all of it to the LLM on each turn. It is the simplest memory type and is best for short conversations where context fits within the model's token limit. It does not summarize, window, or truncate.

A developer wants to index a large corpus of HTML web pages for a RAG pipeline using LangChain. They need to load the content from URLs, split the text into chunks, and generate embeddings. Which combination of LangChain components should they use?

PDFLoader, RecursiveCharacterTextSplitter, OCIGenAIEmbeddings

WebBaseLoader, RecursiveCharacterTextSplitter, OCIGenAIEmbeddings

WebBaseLoader fetches and parses HTML from URLs, satisfying the requirement to load content directly from web pages. RecursiveCharacterTextSplitter then chunks the extracted text, and OCIGenAIEmbeddings generates the vectors for the RAG pipeline, completing the load-split-embed sequence the scenario demands.

CSVLoader, RecursiveCharacterTextSplitter, OCIGenAIEmbeddings

WebBaseLoader, TokenTextSplitter, OCIGenAI

Why: WebBaseLoader is designed to load and parse HTML content from URLs, making it the correct loader for web pages. RecursiveCharacterTextSplitter is the standard splitter for chunking text while preserving semantic boundaries, and OCIGenAIEmbeddings generates embeddings using OCI's Generative AI service. This combination covers loading, splitting, and embedding for a RAG pipeline.

In LangChain, what is the purpose of the LCEL (LangChain Expression Language) | operator?

To pipe the output of one component into the next component

LCEL's pipe operator composes runnables into a sequence, feeding each component's output as the next component's input. This creates a declarative chain supporting streaming, batching and async execution, so prompt templates, models and parsers connect without custom glue code.

To run two chains in parallel

To concatenate two prompt templates

To compare outputs of two different models

Why: In LCEL, the pipe (|) operator composes runnables by chaining them so the output of the left component becomes the input of the right component, similar to Unix pipes. This enables declarative construction of sequences like prompt | model | parser. It is the core mechanism for building chains in modern LangChain.

Want more LangChain and AI Application Development practice?

All Using OCI Generative AI Service questions

Domain 8: Using OCI Generative AI Service

12% of exam · 6 sample questions below

A data scientist is using OCI Generative AI Service to generate product descriptions. They notice that the output often repeats phrases. Which parameter adjustment would MOST directly address this issue?

Increase the temperature

Increase the max tokens

Increase the frequency penalty

Frequency penalty scales down the logits of tokens already generated in the output, directly discouraging the model from repeating the same phrases. Raising it satisfies the stem's repetition constraint more directly than temperature or top-p, which affect randomness rather than penalising prior token reuse.

Decrease the top-p value

Why: The frequency penalty directly reduces the likelihood of the model repeating the same phrases by penalizing tokens that have already appeared in the generated text. In OCI Generative AI Service, this parameter subtracts a fixed value from the log-probability of each token each time it is generated, making repeated tokens less likely to be chosen again. This is the most direct mechanism to address repetitive output.

A company needs to integrate OCI Generative AI Service with an existing application that uses OCI IAM for authentication. They want to use resource principal to allow the application to call the service without storing API keys. Which step is REQUIRED?

Create an OCI API key for the application

Enable the Generative AI Service for resource principal in the tenancy

Assign the application to a group with admin privileges

Create a dynamic group and a policy granting access to the Generative AI Service

Resource principal authentication requires the calling application to be a member of a dynamic group, matched by instance or resource rules. A policy then grants that dynamic group permission to call the Generative AI Service, eliminating stored API keys.

Why: Resource principal authentication in OCI requires the application to be represented by a dynamic group, which matches instances or resources based on defined rules. A policy must then grant that dynamic group access to the Generative AI Service. This avoids storing API keys by using OCI IAM's built-in resource principal token exchange.

Refer to the exhibit. A user runs the command shown and receives the error: 'ServiceError: NotAuthorizedOrNotFound'. What is the MOST likely cause?

The CLI is not configured with OCI credentials

The user does not have the 'inspect' permission on the model

NotAuthorizedOrNotFound is returned when the caller lacks the inspect permission on the model resource; OCI masks authorisation failures as not-found, so the missing inspect verb on the model is the most likely cause of the error.

The model ID is incorrectly formatted

The model is in a different region than iad

Why: The error 'NotAuthorizedOrNotFound' in OCI is a generic error that can occur either when the resource does not exist or the user lacks the necessary permission to access it. Given that the model ID and region are likely correct (otherwise a different error like 'InvalidParameter' would appear), the most probable cause is that the user does not have the 'inspect' permission on the model. This permission is required to view model details. Option A would result in a credential configuration error, not this generic error. Option C would produce an invalid model ID error. Option D is less likely because if the model were in a different region, the error would typically indicate a region mismatch rather than a generic authorization error. Therefore, option B is correct.

An enterprise deployed a custom fine-tuned model for generating financial reports. After the first month, the model's outputs began to include outdated information and occasional factual errors. The team suspects data drift. What is the best course of action?

Switch to a newer base model like Llama 3.1 without retraining.

Decrease the temperature parameter to 0.1 to reduce model creativity.

Retrain the model on the latest financial data and monitor for drift.

Retraining on current financial data directly addresses drift by refreshing the model's learned patterns, correcting outdated outputs and factual errors. Ongoing drift monitoring then detects future distribution shifts, satisfying the stem's requirement to restore accuracy and prevent recurrence.

Increase the max tokens value to allow longer responses.

Why: Data drift occurs when the statistical properties of the input data change over time, causing a fine-tuned model's learned patterns to become stale. The only way to restore accuracy is to retrain the model on current, representative financial data and then continuously monitor for further drift. This directly addresses the root cause rather than masking the symptom.

A developer is using OCI Generative AI Service to generate product descriptions. The outputs are often too generic and lack brand-specific tone. The developer has a small set of 20 high-quality example descriptions. What is the most efficient approach to improve output quality?

Fine-tune a base model on the 20 examples.

Use few-shot prompting by including the 20 examples in the prompt.

Few-shot prompting places the 20 curated examples directly in the context window, letting the model infer the desired brand tone through in-context learning. This satisfies the constraint of a small example set without retraining or fine-tuning, making it the most efficient route to less generic output.

Use a more detailed system prompt describing the brand tone.

Use chain-of-thought prompting to guide the model step by step.

Why: Few-shot prompting is the most efficient approach when you have a small set of high-quality examples (20 in this case). It allows the model to infer the desired tone and style directly from the provided examples without requiring any training or fine-tuning, which would be inefficient and potentially ineffective with such a small dataset. In OCI Generative AI Service, few-shot prompting leverages the model's in-context learning capability to adapt its output to the brand-specific tone.

A team is using OCI Generative AI Agents to build a customer support bot. The bot sometimes generates answers that contradict the knowledge base. What is the most likely cause?

The chunking strategy for the knowledge base does not capture enough context overlap.

Insufficient chunk overlap splits related sentences across separate chunks, so retrieval returns fragments lacking the surrounding context needed for a grounded answer. The model then fills gaps from its parametric knowledge, producing responses that contradict the knowledge base.

The max tokens value is too low, truncating the response.

The temperature parameter is set too high, causing the model to hallucinate.

The model's repetition penalty is too high.

Why: When the chunking strategy lacks sufficient context overlap, the retrieved chunks may omit critical surrounding information, causing the generative AI model to infer missing details incorrectly and produce answers that contradict the knowledge base. In OCI Generative AI Agents, the chunking strategy determines how documents are split into smaller pieces for retrieval; without adequate overlap, the model loses the semantic continuity needed to stay faithful to the source material.

Want more Using OCI Generative AI Service practice?

Browse all 1Z0-1127-25 questions Take a timed practice test

Frequently asked questions

How many questions are on the 1Z0-1127-25 exam?

The 1Z0-1127-25 exam has 40 questions and must be completed in 90 minutes. The passing score is 65/1000.

What types of questions appear on the 1Z0-1127-25 exam?

Scenario-based questions covering exam objectives with detailed answer explanations.

How are 1Z0-1127-25 questions organised by domain?

The exam covers 8 domains: Building LLM Applications with RAG and Vector Search, Fundamentals of Large Language Models, Prompt Engineering, Deploying and Managing Generative AI on OCI, OCI Generative AI Service, LLM Fundamentals, LangChain and AI Application Development, Using OCI Generative AI Service. Questions are weighted by domain — higher-weight domains appear more on your actual exam.

Are these the actual 1Z0-1127-25 exam questions?

No. These are original exam-style practice questions written against the official Oracle 1Z0-1127-25 exam objectives. They are not copied from the real exam. Courseiva focuses on genuine understanding, not memorisation of braindumps.

Ready to practice all 729 1Z0-1127-25 questions?

Courseiva tracks your accuracy per domain and routes you toward weak areas automatically. Free, no account required.

Oracle · Free Practice Questions · Last reviewed May 2026

1Z0-1127-25 Exam Questions and Answers

48real exam-style questions organised by domain, each with the correct answer highlighted and a plain-English explanation of why it's right — and why the others are wrong.

40 exam questions

90 min time limit

Pass: 65/1000

8 exam domains

Overview Domain Blueprint Study Guide All QuestionsSample by Domain

Domain 1: Building LLM Applications with RAG and Vector Search

12% of exam · 6 sample questions below

All Building LLM Applications with RAG and Vector Search questions

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

Adjust the chunk size and chunk overlap to better capture coherent passages.

Increase the chunk size to capture more context.

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

Create an ANN index on the embedding vector column.

Create a bitmap index on the embedding vector column.

Create an inverted index on the document text column.

Create a B-tree index on the document text column.

Increase the chunk size to include entire invoices.

Apply stemming and lemmatization to the text before chunking.

Tag each chunk with metadata such as invoice number, date, and vendor, and use metadata filtering during retrieval.

Switch from dense embeddings to sparse embeddings for better exact match.

Deploy the generative AI model endpoints within the same OCI region as the data and compute.

Use OCI Generative AI endpoints in a different region but store data in the required region.

Use an external third-party LLM endpoint that guarantees data residency.

Store embeddings in a different region but run inference in the required region.

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?

Decrease the chunk size to focus on smaller units.

Increase the number of retrieved chunks to cover more variations.

Use a spell-checker on the retrieved chunks.

Implement query rewriting or expansion using a language model before embedding.

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

Use a vector database such as OCI OpenSearch with ANN indexes for storing embeddings.

Generate embeddings for documents at query time to ensure freshness.

Pre-index the documents and update the index periodically to reflect new content.

Store the source documents only in OCI Object Storage and retrieve them at query time using full-text search.

Use a different embedding model for documents and queries to capture distinct semantics.

Want more Building LLM Applications with RAG and Vector Search practice?

All Fundamentals of Large Language Models questions

Domain 2: Fundamentals of Large Language Models

12% of exam · 6 sample questions below

Employ retrieval-augmented generation (RAG) with a general model

Rely solely on prompt engineering with a general model

Use a large general-purpose LLM with zero-shot prompting

Fine-tune a small open-source LLM on domain-specific data

A data scientist observes that their fine-tuned LLM performs well on training data but generates repetitive and dull responses in production. What is the most likely cause and best solution?

The model is overfitted; apply stronger regularization

The temperature is set too low; increase temperature during inference

The training data lacks diversity; add more varied examples

The model has too many layers; reduce model size

An organization wants to use an LLM to summarize legal documents. Which consideration is most important for ensuring accurate summaries?

Fine-tune the model on a curated legal corpus

Use the largest available general-purpose model

Rely on zero-shot summarization with careful prompting

Pre-train a new model from scratch on legal texts

A developer is building a code generation assistant. The model occasionally produces syntactically correct but semantically wrong code. Which technique directly addresses semantic correctness?

Expand the token vocabulary

Lower the temperature to 0

Apply RLHF using human-validated code examples

Increase beam search width

A company fine-tunes an LLM on internal support tickets. After deployment, the model hallucinates company-specific product names. What is the most effective mitigation?

Switch to a smaller model to reduce hallucination risk

Use prompt engineering to remind the model to be accurate

Implement RAG with a verified product database

Fine-tune further with more ticket data

A team wants to evaluate an LLM's performance on a text classification task. Which metric is most appropriate for a balanced dataset?

BLEU score

Perplexity

Accuracy

ROUGE score

Want more Fundamentals of Large Language Models practice?

All Prompt Engineering questions

Domain 3: Prompt Engineering

13% of exam · 6 sample questions below

"Write a report with three sections: Summary, Findings, Recommendations."

"Provide the output in JSON format with keys: 'summary', 'findings', and 'recommendations'."

"Return the report in bullet points."

"Output the report as a markdown document with headings."

Few-shot prompting

Temperature tuning

Tree-of-thought prompting

Self-consistency

Which parameter controls the creativity and randomness of a model's output by adjusting the probability distribution before sampling the next token?

Frequency penalty

Max tokens

Temperature

Top-k

"You have access to an API. For each step, output 'Thought:', then 'Action:', then 'Observation:' before the final answer."

"You are a helpful assistant. Answer the user's question based on your knowledge."

"First, call the API. Then, output the result."

"Think step by step, then provide the final answer."

"You are an expert in the field. Use your extensive knowledge to answer."

"Provide a detailed answer with references."

"Use a temperature of 0.0 for factual answers."

"Answer the question based solely on the provided document. If the document does not contain the answer, say 'I don't know'."

In few-shot prompting, what is the primary purpose of including examples in the prompt?

To reduce the need for a system prompt

To provide a template for the desired output format and reasoning pattern

To increase the model's vocabulary

To decrease the computational cost of inference

Why: Examples guide the model on the desired input-output pattern, improving task performance without fine-tuning.

Want more Prompt Engineering practice?

All Deploying and Managing Generative AI on OCI questions

Domain 4: Deploying and Managing Generative AI on OCI

12% of exam · 6 sample questions below

NAT Gateway

Dynamic Routing Gateway (DRG)

Internet Gateway

Service Gateway

Service gateway enables private subnet access to OCI services like Data Science.

Enable the OCI Generative AI inference optimizer

Deploy dedicated AI clusters in regions closer to the users

Increase the number of nodes in the dedicated AI cluster

Use a content delivery network (CDN) to cache responses

A developer wants to call the OCI Generative AI service from a Python application running on an OCI Compute instance. Which method is the most secure for authenticating the API calls?

Use a resource principal

Use the OCI CLI with a config file containing credentials

Use instance principals with a dynamic group and policy

Use an API signing key stored on the instance

Which THREE components are required to deploy a custom generative AI model on OCI Data Science model deployment?

A load balancer to distribute traffic

An inference script (e.g., score.py) to handle prediction requests

A model artifact containing the model files

An API signing key for authentication

A deployment configuration specifying resources and environment

Which TWO are valid methods to monitor the performance of a generative AI model deployed on OCI Data Science?

Use OCI Notifications to receive alerts on model drift

Use OCI Monitoring service to track custom metrics like latency and throughput

Use OCI Logging service to collect inference logs

Use OCI Events service to trigger retraining on low accuracy

Use OCI Audit service to review API call logs

The cluster is hitting the maximum inference requests per minute limit

The cluster does not have enough nodes to handle the load

The user is not in the same compartment as the cluster

The cluster is not in ACTIVE state

Want more Deploying and Managing Generative AI on OCI practice?

All OCI Generative AI Service questions

Domain 5: OCI Generative AI Service

13% of exam · 6 sample questions below

You need to convert a set of customer support tickets into vector embeddings for a similarity search application. Which OCI Generative AI model should you use?

Cohere Rerank

Cohere Embed (e.g., embed-english-v3.0)

Meta Llama 3

Cohere Command R

Set the 'stop_sequences' parameter to include periods

Set the 'temperature' parameter to 0.1

Use the 'system' parameter (or preamble_override) to provide a system message like 'You are a formal assistant'

Set the 'max_tokens' parameter to 200

Re-sync the knowledge base after updating the documents in Object Storage

Use the Embedding API to manually index each new document

Set the session API to refresh automatically

Recreate the agent each time documents change

You want to test different prompts and parameters (temperature, max tokens) for a summarization task using a foundation model without writing any code. Which OCI tool should you use?

OCI Console -> Generative AI -> Models

OCI Generative AI Playground

OCI CLI with the 'oci generative-ai' commands

Python SDK with InferenceClient

Why: The OCI Generative AI Playground provides an interactive UI to experiment with models and parameters. CLI, SDK, and console navigation are not for interactive experimentation.

The base model selected does not support fine-tuning

The dataset is in the wrong compartment

The fine-tuning job does not have enough model units allocated

The JSONL file uses 'input' and 'output' as key names instead of 'prompt' and 'completion'

An application needs to generate embeddings for text in multiple languages (English, Spanish, French). Which OCI Generative AI embedding model should be used?

embed-english-v3.0

Cohere Command R

embed-multilingual-v3.0

Meta Llama 3

Want more OCI Generative AI Service practice?

All LLM Fundamentals questions

Domain 6: LLM Fundamentals

13% of exam · 6 sample questions below

What is the primary purpose of the self-attention mechanism in a Transformer model?

To generate token embeddings in parallel

To reduce the dimensionality of token embeddings

To encode positional information of tokens

To compute a weighted sum of all token representations based on pairwise relevance

Why: Self-attention allows each token to attend to every other token in the sequence, capturing contextual relationships regardless of distance.

Which of the following best describes the difference between an encoder-only model (e.g., BERT) and a decoder-only model (e.g., GPT)?

Encoder-only uses bidirectional attention and is suited for classification or NER; decoder-only uses causal attention and is suited for text generation

Encoder-only is trained for text generation; decoder-only is trained for classification

Both use the same attention pattern but differ in number of layers

Encoder-only uses causal attention; decoder-only uses bidirectional attention

A practitioner wants to evaluate an LLM-generated summary against a human-written reference using a metric that focuses on recall of key information. Which metric is most appropriate?

BLEU

Perplexity

Cosine similarity

ROUGE

A company needs to generate embeddings for a large corpus of legal documents to enable semantic search. Which type of model should they use?

An encoder-only embedding model like Cohere Embed

A decoder-only generation model like GPT

A text-to-speech model

A machine translation model

Which of the following sampling strategies selects tokens based on a cumulative probability threshold from the highest probability tokens?

Top-p (nucleus) sampling

Top-k sampling

Greedy decoding

Temperature sampling

Why: Top-p (nucleus) sampling cuts off the tail of the probability distribution where cumulative probability exceeds p, allowing dynamic vocabulary size.

Use a longer context window and include all new articles in the prompt

Fine-tune the model again with the new data

Implement a RAG pipeline that indexes the latest documents into a vector store and retrieves relevant passages at query time

Increase the temperature parameter to encourage more creative outputs

Want more LLM Fundamentals practice?

All LangChain and AI Application Development questions

Domain 7: LangChain and AI Application Development

13% of exam · 6 sample questions below

In LangChain, which component is responsible for connecting a language model to a retriever and a prompt template to answer questions based on retrieved documents?

RetrievalQA chain

LLMChain

SequentialChain

AgentExecutor

as_retriever()

from_texts()

max_marginal_relevance_search()

similarity_search()

Implement a retry mechanism with exponential backoff when calling the model

Increase the k value in the retriever to reduce the number of API calls

Switch to a smaller model to reduce token consumption

Reduce the chunk_size parameter in text splitters

Which LangChain memory type stores the entire conversation history as a list of messages and is best for simple, short conversations?

ConversationTokenBufferMemory

ConversationSummaryMemory

ConversationBufferMemory

ConversationBufferWindowMemory

PDFLoader, RecursiveCharacterTextSplitter, OCIGenAIEmbeddings

WebBaseLoader, RecursiveCharacterTextSplitter, OCIGenAIEmbeddings

CSVLoader, RecursiveCharacterTextSplitter, OCIGenAIEmbeddings

WebBaseLoader, TokenTextSplitter, OCIGenAI

In LangChain, what is the purpose of the LCEL (LangChain Expression Language) | operator?

To pipe the output of one component into the next component

To run two chains in parallel

To concatenate two prompt templates

To compare outputs of two different models

Want more LangChain and AI Application Development practice?

All Using OCI Generative AI Service questions

Domain 8: Using OCI Generative AI Service

12% of exam · 6 sample questions below

Increase the temperature

Increase the max tokens

Increase the frequency penalty

Decrease the top-p value

Create an OCI API key for the application

Enable the Generative AI Service for resource principal in the tenancy

Assign the application to a group with admin privileges

Create a dynamic group and a policy granting access to the Generative AI Service

Refer to the exhibit. A user runs the command shown and receives the error: 'ServiceError: NotAuthorizedOrNotFound'. What is the MOST likely cause?

The CLI is not configured with OCI credentials

The user does not have the 'inspect' permission on the model

The model ID is incorrectly formatted

The model is in a different region than iad

Switch to a newer base model like Llama 3.1 without retraining.

Decrease the temperature parameter to 0.1 to reduce model creativity.

Retrain the model on the latest financial data and monitor for drift.

Increase the max tokens value to allow longer responses.

Fine-tune a base model on the 20 examples.

Use few-shot prompting by including the 20 examples in the prompt.

Use a more detailed system prompt describing the brand tone.

Use chain-of-thought prompting to guide the model step by step.

A team is using OCI Generative AI Agents to build a customer support bot. The bot sometimes generates answers that contradict the knowledge base. What is the most likely cause?

The chunking strategy for the knowledge base does not capture enough context overlap.

The max tokens value is too low, truncating the response.

The temperature parameter is set too high, causing the model to hallucinate.

The model's repetition penalty is too high.

Want more Using OCI Generative AI Service practice?