CCNA Oci Genai Prompt Engineering Questions

System prompt is designed to set persona, tone, and constraints. Including both tone and constraints in the system prompt is the intended practice.

Providing a JSON schema with explicit instructions and constraints directly in the prompt is the most reliable way to enforce exact structure.

Role prompting explicitly sets the persona (e.g., 'You are an expert customer support agent') which guides tone and behavior. The system message is the ideal place for this.

Frequency penalty discourages tokens that have already appeared, and presence penalty discourages tokens that have appeared at all. Both reduce repetition. Temperature and max tokens do not directly target repetition.

Template patterns provide a fixed structure (e.g., fill-in-the-blanks) that the model follows, ensuring consistent output format.

Cohere Command models support a special document-grounded generation syntax using the 'document:' prefix. This tells the model to treat the following text as a reference document for grounding.

The ReAct pattern (Reason + Act) prompts the model to output reasoning steps and then perform actions (like API calls), enabling interactive problem-solving.

Specifying the output format (bulleted list, no intro text) directly in the instruction is the most straightforward way to control the structure. Few-shot examples could also work but are unnecessary when a clear instruction suffices.

Explicitly constraining the output to French only, with a clear prohibition against other languages, directly addresses language mixing.

Versioning prompts and establishing evaluation criteria are key to tracking changes and ensuring quality. Without versioning, it's impossible to know which version produced which result.

Few-shot prompting (Option C) is the correct answer because it explicitly involves providing the model with a small set of input-output examples within the prompt to guide its response. This technique helps the model understand the desired task format, style, or reasoning pattern without requiring fine-tuning, leveraging in-context learning to adapt its output based on the provided demonstrations.

Setting a low temperature reduces randomness (consistency). Including a system prompt with tone and length constraints directly addresses conciseness and format.

Cohere's document-grounded generation syntax uses special tags to clearly separate the document from the query, ensuring the model focuses on the provided content rather than its training data.

Few-shot prompting includes several demonstrations of the desired task, helping the model understand the expected output format and reasoning.

Cohere's document-grounded generation requires the preamble to instruct the model to answer based solely on the documents, and the conversation history must include the documents in the correct format.

Self-consistency involves generating multiple reasoning paths, then selecting the most consistent answer. It does not require a single chain-of-thought or tree-of-thought expansion.

Self-consistency generates multiple reasoning paths (e.g., using chain-of-thought) and then takes a majority vote or averages results, which directly matches the need for multiple paths and aggregation.

A/B testing helps compare prompt variants, and establishing evaluation criteria ensures objective measurement of improvements. The other options are either irrelevant or counterproductive.

ReAct explicitly interleaves reasoning (Thought) and actions (Action) before final output.

Explicit instruction to base answers solely on provided context, with a constraint to say if information is missing, directly reduces hallucinations.

Cohere's document-grounded generation uses <results> tags to include document text.

Chain-of-thought prompting explicitly instructs the model to think step by step, improving reasoning accuracy.

ReAct stands for Reason + Act. The model first reasons about the question, then decides on an action (e.g., a tool call) to gather information, iterating until a final answer is reached.

A/B testing involves running both prompt variants on the same inputs and comparing outputs against human-annotated ground truth. This provides quantitative evidence of which prompt performs better.

Setting a system prompt (or preamble) instructs the model on its role, tone, and constraints before the user message. This is the standard way to enforce persona and tone consistently.

Self-consistency generates multiple reasoning paths (e.g., with higher temperature) and selects the most consistent answer by majority vote, improving reliability.

Frequency penalty reduces the model's tendency to repeat tokens or phrases by penalizing tokens that have already appeared in the generated text.

Providing only a task instruction ('Write a poem') without specifying the rhyme scheme or giving examples leaves the model to choose its own structure. The other options give explicit formatting or examples.

Option A is correct because setting the system prompt to explicitly instruct the model to output only Python code without explanations directly enforces the desired behavior at the highest priority level of the prompt hierarchy. This approach leverages the system prompt's role as a persistent instruction that overrides user messages, ensuring the model strictly returns code blocks without extraneous text.

RAG (Retrieval-Augmented Generation) allows the LLM to retrieve relevant document sections at inference time, so knowledge stays current without retraining. The other options either require expensive retraining for each update or lack document grounding.

Temperature adjusts the logits before softmax, making lower values (e.g., 0.1) more deterministic and higher values (e.g., 0.9) more random.

Lowering temperature (e.g., to 0.2) makes the model more deterministic and focused, reducing creativity and off-topic responses.

Testing with diverse inputs, establishing evaluation criteria, and A/B testing prompt variants are core to iterative refinement.

Frequency penalty reduces the chance of repeating tokens that have already appeared, directly mitigating repetition. Presence penalty also helps but is broader; frequency penalty is more targeted.

Chain-of-thought requires the model to output intermediate reasoning steps, and providing an example with reasoning helps guide the model.

Cohere's document-grounded generation uses a special preamble format that includes document references. The correct syntax is to enclose document text in <doc> tags within the preamble.

Option D is correct because it explicitly prohibits the model from generating DDL (Data Definition Language) and DML (Data Manipulation Language) statements, directly addressing the risk of unsafe queries like DROP TABLE. By constraining the output to only SELECT statements, the prompt enforces a strict policy that prevents the model from producing destructive or modifying SQL commands, which is the most effective mitigation among the options.

The system prompt in prompt engineering defines the model's persona, tone, and behavioral constraints, setting the overarching context for all interactions. This is distinct from user prompts, which carry the current query. By establishing these parameters, the system prompt guides the model's responses consistently across a session, ensuring alignment with desired output characteristics.

ReAct requires a scratchpad to record reasoning, a set of available actions (tools), and a format showing how to interleave reasoning and actions.

Option A is correct because Cohere Command R supports a specific document-grounded generation syntax where each document is prefixed with 'document:' markers. This tells the model to base its answers strictly on the provided documents, reducing hallucination and ensuring grounded responses. The syntax is part of Cohere's native prompt engineering guidelines for RAG (Retrieval-Augmented Generation) workflows.

Versioning, storing templates in a central library, and establishing evaluation criteria are key to managing prompts. A/B testing is good but not a management practice; parameter tuning is separate.

ReAct interleaves reasoning steps (e.g., 'I need to find the current weather') with actions (e.g., 'Action: call weather API') and observations, allowing the model to reason and act in a cycle.

The frequency penalty reduces the likelihood of repeating tokens that have already appeared. A moderate penalty (e.g., 0.3) discourages repetition while allowing creative word choices. Temperature and top-k affect randomness, not repetition.

Option B is correct because defining a system prompt that specifies the role of a legal expert and constraints guides the OCI Generative AI model to adopt a precise, authoritative tone and adhere to domain-specific rules. This is a core prompt engineering technique that sets the context and boundaries for the model's behavior, directly improving accuracy and compliance with legal standards.

Specifying JSON output with clear keys ensures the model returns a structured, machine-parseable result. Natural language descriptions are ambiguous, and markdown may not be reliably parsed.

Stop sequences tell the model when to stop generating further tokens, allowing control over output length or termination upon specific strings.

Input filtering blocks malicious inputs, output filtering catches harmful responses before delivery, and system prompt reinforcement strengthens initial instructions. Adding more few-shot examples does not directly address safety.

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.

Self-consistency generates several reasoning chains and selects the most common answer, improving robustness even if some chains have flawed steps.

A template uses placeholders like {product_name} that are filled at runtime, making prompts reusable and dynamic.

Instructing the model to output JSON and setting a stop sequence to prevent extra text ensures the desired output format.

Explicitly requesting a bullet list in the output format specification is the most direct way to achieve the desired structure.

Chain-of-thought encourages the model to perform step-by-step reasoning before arriving at an answer, improving performance on complex tasks.

Tree-of-thought explores multiple reasoning branches in parallel, uses evaluation or heuristics to prune unpromising branches, and can backtrack to explore alternatives. It does not follow a single linear path or guarantee a single answer without voting.

Top-k restricts the model to sample only from the k most likely next tokens, reducing the chance of unusual or off-topic words. Top-p is nucleus sampling; temperature controls randomness; frequency penalty reduces repetition.

Temperature controls randomness; low values make the model deterministic and focused on the most likely tokens, which is ideal for factual tasks.

CoT encourages the model to articulate intermediate reasoning steps, which improves accuracy on tasks that require multi-step logic. Few-shot provides examples but not the reasoning process.

Ambiguous instructions, insufficient context, and prompt injection are well-known failure modes.

Explicitly specifying the output format (e.g., 'Provide the answer as a JSON object with keys ...') is essential for structured output. The other components are important for other aspects but not for format compliance.

Option A is correct because defining the JSON schema in the system prompt explicitly instructs the model on the exact structure and data types required for the output. This is a foundational practice in prompt engineering for structured data generation, as it reduces ambiguity and ensures the model adheres to a predefined format, which is critical for downstream parsing in legal document analysis.

Retrieval-Augmented Generation (RAG) is the most appropriate approach because it allows the chatbot to answer questions based on the latest policy documents without retraining the model. By indexing the documents in a vector store and retrieving relevant chunks at query time, RAG provides up-to-date answers while keeping the underlying LLM static, which directly addresses the requirement of monthly updates without retraining.

Adding a directive in the preamble, such as "Provide thorough and detailed responses," sets the desired behavior from the start.

The preamble sets the task, conversation history maintains context, and the document syntax provides source material.

Oracle's generative AI services support a system prompt (or preamble in Cohere) that sets the assistant's persona, which applies to the entire conversation.

The preamble sets the chatbot's persona and rules. Conversation history format allows passing previous exchanges for context. Document-grounded generation is for knowledge base retrieval but not for multi-turn context.

A/B testing with a holdout evaluation set allows objective comparison of prompt variants and measures performance improvements reliably.

Stop sequences tell the model when to stop generating. By adding a stop sequence like '}' (end of JSON), the model will terminate after the JSON object, preventing extra text.

Using a system prompt to set the persona (e.g., 'You are a JSON generator') and including a step-by-step instruction reduces unwanted text. Cohere's preamble works like a system prompt to enforce constraints.

Frequency penalty reduces the likelihood of tokens that have already appeared, directly targeting repetition of phrases.

Lowering temperature reduces randomness, making outputs more deterministic and less prone to hallucinations. Frequency penalty reduces repetitive mistakes. Top-k and presence penalty are less directly effective.

Few-shot prompting includes examples of desired input-output pairs, helping the model infer the task without fine-tuning.

Adding few-shot examples of correct code directly in the prompt provides the model with explicit patterns to follow, reducing syntactic drift. This technique, known as few-shot prompting, anchors the model's output to the demonstrated structure and syntax, which is far more effective than relying on the model's internal knowledge alone for code generation tasks.

Storing prompt templates in a centralized prompt library with version control enables systematic management, collaboration, and rollback. It also supports A/B testing different versions.