CCNA Oci Genai Service Questions

The OCI Generative AI Playground provides a no-code interface to test models, adjust parameters, and experiment with prompts interactively.

Option D is correct because the Embedding API in OCI Generative AI requires specifying the input type as 'search_query' when generating embeddings for search queries in a semantic search system. This input type optimizes the embedding model to produce vectors that are specifically tuned for query-side representation, ensuring better alignment with document embeddings during similarity search.

A Dedicated AI Cluster provides dedicated inference capacity with low latency, ideal for production fine-tuned models. Shared infrastructure may have variable latency.

On-demand pricing is pay-per-token, suitable for batch workloads without dedicated capacity; it's cost-effective for sporadic or large batch jobs.

The embed-multilingual-v3.0 model is designed for multilingual text. The English-only model would not handle other languages well.

A Dedicated AI Cluster provides reserved compute with low latency and high throughput, ideal for production workloads with custom models. Shared infrastructure may have variable performance.

Option B is correct because a knowledge base is the core repository that stores the indexed content used by OCI Generative AI Agents to retrieve relevant information for answering queries. Without a knowledge base, the agent has no source of domain-specific data to ground its responses, making it a mandatory component.

Cohere Command R+ and Meta Llama 3 support multiple languages.

The input type 'clustering' optimizes embeddings for clustering tasks.

The Chat API does not automatically manage conversation history; the developer must provide previous messages. The model itself retains state only within the provided context.

Dedicated AI Clusters provide isolated, low-latency inference for custom models. Shared infrastructure is multi-tenant and may have higher latency. On-demand tokens and serving endpoints without a cluster do not offer dedicated resources.

The fine-tuning job creation request includes parameters such as 'baseModelId' and 'trainingDataset' (pointing to the dataset in Object Storage). The model deployment endpoint and cluster are separate steps.

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.

T-Few is parameter-efficient and may require more data. Increasing dataset size or using data augmentation is a likely improvement.

Temperature controls randomness; frequency penalty reduces repetition of words/phrases; presence penalty encourages new topics.

For clustering tasks, the 'clustering' input type optimizes the embeddings for that purpose. The other types are for different tasks.

OCI Generative AI expects a JSONL file where each line is a JSON object with 'prompt' and 'completion' fields. CSV, Parquet, and text files are not supported for fine-tuning.

OCI Generative AI Agents provides a managed RAG service that can ingest documents from Object Storage and answer questions based on the ingested knowledge base.

The 'inspect' verb on dedicated-ai-clusters prevents creating or managing clusters while allowing use of other GenAI resources. 'use' on generative-ai-family allows using the resources. Option A denies all GenAI resources, B grants full access including clusters, C uses incorrect resource type.

OCI Generative AI fine-tuning expects training data in JSONL format with specific fields.

Option C is correct because the 'manage' verb on the 'genai-family' resource type grants full access (including use) to OCI Generative AI resources, and scoping the policy to 'compartment prod' restricts the permission to only that compartment. The requirement is to allow the 'DataScientists' group to use (which implies manage-level access for creating and running inference jobs) Generative AI resources specifically in the 'prod' compartment, not the entire tenancy.

The OCI Generative AI Playground provides an interactive web UI to test models and adjust parameters.

Latency sensitivity, throughput consistency, and cost predictability are key factors. On-demand is variable cost with potential contention; dedicated offers fixed cost with reserved capacity. Model accuracy does not differ based on pricing model, and data residency is a compliance factor but not directly tied to pricing model choice.

Lowering temperature reduces randomness, increasing frequency penalty penalizes repeated tokens, and setting appropriate max tokens controls output length. Stop sequences define when generation stops, and presence penalty penalizes token presence overall.

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, the system retrieves relevant chunks at query time and passes them as context to a frozen LLM, ensuring the model always uses the most current information.

On-demand pricing (pay-per-token) and using a smaller/faster model (like Command R instead of R+) are cost-saving measures. Dedicated clusters increase cost; the largest model is more expensive; increasing temperature doesn't affect pricing.

Option A is correct because the 'use' verb in OCI IAM policies grants the ability to perform operational actions on resources without allowing management or administrative changes. For the OCI Generative AI service, 'use generative-ai-family' permits data scientists to create endpoints and run inference (the core actions needed), while explicitly preventing them from managing IAM policies or altering resource configurations. This aligns with the principle of least privilege required by the security administrator.

Embed-multilingual-v3.0 is designed for multilingual embedding tasks. The other models are primarily for text generation or English-only embeddings.

The agent requires a knowledge base that is connected to the data source. Directly creating a session without a knowledge base and agent will fail.

In OCI Generative AI Agents, you create a knowledge base from data sources like Object Storage. The agent then uses this knowledge base to retrieve relevant information for answering questions. Creating a dedicated cluster or fine-tuning is not required for RAG with agents.

The training dataset and the base model are mandatory inputs for a fine-tuning job. The compartment is part of the resource configuration, and the hyperparameters file is optional but not required.

The Cohere Embed API uses the `search_query` input type specifically for embedding search queries in a semantic search system. This tells the model to optimize the embedding for matching against documents that were embedded with the `search_document` type, ensuring proper alignment in the vector space for retrieval tasks.

Temperature controls the randomness of the output. Higher temperature (e.g., 0.8) makes the model more creative and varied. Max tokens, frequency penalty, and stop sequences do not primarily affect creativity.

In OCI Generative AI fine-tuning, the dataset must be a JSON file with exactly 'prompt' and 'completion' fields. If these fields are missing or incorrectly named, the service cannot parse the training data, so the model never learns from the actual content, causing the training loss to remain flat across epochs. This is the most direct cause of a non-decreasing loss when the dataset structure is invalid.

Cohere Rerank is specifically designed for reranking documents to improve relevance ranking.

T-Few is a parameter-efficient fine-tuning method that updates only a small fraction of model parameters, making it faster and more resource-efficient than full fine-tuning. It does not train all parameters, add new layers, or require unlabeled data.

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.

The Embedding API generates vector embeddings from text, which can be used for semantic search, clustering, etc.

Embedding is the correct answer because it is the OCI Generative AI service component that converts text into dense vector representations (embeddings). These numerical vectors capture semantic meaning, enabling similarity comparisons for tasks like semantic search and clustering, where documents with similar vectors are considered contextually related.

Option C is correct because the OCI GenAI Chat API supports a 'system message' or 'preamble' parameter that sets the assistant's behavior and identity for the entire conversation. By setting the preamble to 'You are SupportBot. You must never mention that you are an AI.', the developer enforces the desired persona and restriction across all turns, ensuring the assistant introduces itself as SupportBot and avoids any reference to being an AI.

In OCI Generative AI Agents, a knowledge base is the indexed representation of data sources (like Object Storage buckets). The agent uses the knowledge base to retrieve relevant information.

The Cohere Embed models are designed for text-to-vector embedding. The other options are for text generation or reranking.

To allow a group to manage generative AI resources, you allow them to use the 'generative-ai-family' resource type. Specific verbs like 'inspect' limit visibility but not management. 'Read' only allows viewing, not creating.

Option B is correct because the OCI Generative AI fine-tuning service expects JSONL files where each line contains exactly the keys "prompt" and "completion". This format matches the service's internal training pipeline, which maps the prompt to the input and the completion to the expected output during supervised fine-tuning.

For training a classifier, the 'classification' input type is optimized to generate embeddings that work well for classification tasks. Other types are for different use cases.

Increasing the frequency penalty discourages the model from repeating tokens that have already appeared, reducing repetitive outputs. Temperature and max tokens address randomness and length, not repetition specifically. Stop sequences are for terminating generation early.

Option B is correct because the OCI Generative AI Playground provides a user-friendly interface to directly test prompts against a deployed fine-tuned model endpoint, allowing you to evaluate responses interactively without writing code. Option D is correct because the OCI CLI allows you to call the model inference endpoint with test data, enabling automated or scripted evaluation of the fine-tuned model's performance.

Option A is correct because a Generative AI Agent requires a knowledge base to provide domain-specific context for answering queries. The knowledge base is the source of truth that the agent uses to ground its responses, and it must be explicitly created and associated with the agent. Without a knowledge base, the agent would lack the product manual data needed for customer support.

Each JSONL line must contain exactly 'prompt' and 'completion' keys. Extra keys or missing keys cause format errors.

A dedicated AI cluster provides isolated, low-latency inference for custom models. Shared infrastructure does not guarantee isolation and may have higher latency due to contention.

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.

The preamble is sent only on the first turn; it may be truncated or lost as conversation history grows. The developer should inject the preamble in each request or manage history carefully.

The OCI Generative AI Generate API (option D) is specifically designed for text generation tasks, including summarization, by taking a prompt and returning a coherent response. For a long legal document, you would provide the document text as part of the prompt and instruct the model to generate a summary, making the Generate API the correct choice for this use case.

The Summarisation API is designed for efficient, cost-effective summarization. Dedicated clusters are expensive for batch workloads, and embedding-based approaches add complexity and cost.

The embed-multilingual-v3.0 model is designed for multilingual content, making it the best choice for a multilingual dataset. The other options are either English-only or not embedding models.

The OCI Generative AI Playground provides a no-code interface to test models, adjust parameters, and see real-time outputs. It is designed for experimentation before production use.

The Chat API is designed for multi-turn conversations with system prompts and history management.

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.

Option C is correct because the OCI Generative AI Playground provides access to both Cohere and Meta Llama models, allowing users to experiment with these supported model families interactively. This is a core feature of the Playground, enabling users to test and compare outputs from these models without needing to write code.

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.

Adding more model units increases throughput and reduces latency by distributing the load. This is the direct way to improve performance on a dedicated cluster.

Cohere Embed models (e.g., embed-english-v3.0, embed-multilingual-v3.0) are explicitly designed for generating text embeddings. Cohere Command R and R+ are for generation, Meta Llama 3 is a general-purpose LLM, and Cohere Rerank is for re-ranking search results.

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.

The embed-multilingual-v3.0 model supports multiple languages, including English and French.

Temperature controls randomness; higher values produce more creative outputs. The other parameters control other aspects of generation.

OCI Generative AI Agents require a knowledge base, a data source (like Object Storage), and a base LLM to generate responses. The other options are optional.

T-Few fine-tuning is a parameter-efficient technique that updates only a small number of weights, making it suitable for fine-tuning large models with limited compute. It is the technique offered by OCI GenAI for fine-tuning.

Dedicated AI Clusters provide low-latency dedicated inference, and model units are used to allocate capacity for running models, including custom fine-tuned ones. The cluster is specifically designed for hosting fine-tuned models with consistent performance.

Cohere Embed models are specifically designed for embedding text into vectors. Cohere Command and Meta Llama are generative models, not embedding models.

Option C is correct because a Knowledge Base is the core repository that stores the documents or data sources the RAG chatbot retrieves from. OCI Generative AI Agents use a knowledge base to perform retrieval-augmented generation, where the agent first retrieves relevant chunks from the knowledge base and then passes them to the generative model to produce a grounded, context-aware response.

A system prompt sets the bot's behavior and guidelines, and preamble override allows customizing the model's initial instructions. Temperature and max tokens do not define personality or guidelines.