Zero-shot Chain-of-Thought prompting encourages a language model to decompose a problem into intermediate reasoning steps without supplying worked examples in the prompt. The classic prompting addition associated with this technique is “Let's think step by step.” The technique is “zero-shot” because the user does not provide demonstrations showing how comparable problems should be solved; instead, a short natural-language instruction encourages stepwise decomposition.

OpenAI's published prompting guidance historically illustrates this exact technique, explaining that instructing a model to reason through a sequence of steps can improve performance on tasks requiring decomposition. The OpenAI Cookbook specifically gives “Let's think step by step” as an example of an instruction used to elicit a series of reasoning steps.

Setting temperature to zero affects sampling variability rather than creating Chain-of-Thought prompting. Uploading structured data is unrelated to the reasoning technique, and disabling retrieval tools changes the model's information-access environment rather than prompting its problem-solving structure.

Accordingly, C is the intended and technically correct answer. The uploaded source also marks this exact phrase as correct.

Study Guide reference/topic: Introduction to AI Agents — prompting strategies, reasoning decomposition, zero-shot Chain-of-Thought, and agent reasoning patterns.

===============

MCP follows a host-client-server architecture in which the host creates an MCP client for each MCP server it connects to. The official architecture specifies that each MCP client maintains a dedicated connection with its corresponding MCP server . A host connecting to several servers therefore normally manages several MCP client instances rather than multiplexing all servers through one shared client connection. MCP also does not require clients and servers to reside on different machines. STDIO-based servers commonly execute locally, while Streamable HTTP supports remotely deployed servers. Likewise, a remote MCP server can serve many MCP clients, so a server is not permanently restricted to one client. This client-server separation is particularly relevant to OCI Enterprise AI Agents because MCP Calling enables OCI agent workflows to consume capabilities exposed by remote MCP servers through a standardized integration model.

The Vector Stores API provides infrastructure for ingesting content and retrieving the portions that are semantically relevant to a query. Files associated with a vector store can be chunked and prepared for vector-based retrieval, allowing applications and agents to locate content based on semantic similarity rather than only exact lexical matches .

OpenAI's official Vector Stores API supports searching a vector store with a natural-language query and returns relevant content chunks together with similarity scores. The API also supports attaching files to vector stores and configuring the chunking strategy used during ingestion. This architecture is foundational to retrieval-augmented generation and File Search workflows: source material is indexed, a user query retrieves semantically related chunks, and those chunks can then provide grounded context to a model.

Language translation is a generative-model task. Object Storage encryption is a cloud-storage security function, while video streaming is unrelated to the purpose of a vector store.

Accordingly, “Indexing and retrieving data by meaning” is the technically correct description and is also the answer specified by the uploaded question source.

Study Guide reference/topic: OpenAI Responses API and Agents SDK — Vector Stores, semantic retrieval, chunking, File Search, similarity ranking, and RAG.

===============

The defining distinction is the presence of a request identifier and the expectation of a corresponding response. In JSON-RPC 2.0, a normal request contains an id value so that the sender can correlate the response with the request. A notification deliberately omits the ID because no response is expected. The supplied course material identifies exactly this distinction.

MCP uses JSON-RPC 2.0 as its underlying messaging protocol. Its architecture documentation explicitly states that clients and servers exchange requests and responses, while notifications are used where no response is required. MCP's notification examples contain no id field, and the documentation explains that this follows JSON-RPC notification semantics.

The difference has nothing to do with whether data is structured, whether encryption is enabled, or which transport is used. Both requests and notifications can carry structured JSON parameters. Security belongs to the transport/authentication layer, while MCP can transmit JSON-RPC messages over supported transports such as STDIO or Streamable HTTP.

Therefore, B is the precise protocol-level distinction.

Study Guide reference/topic: Model Context Protocol (MCP) Fundamentals — JSON-RPC 2.0 requests, responses, IDs, and notifications.

===============

MCP addresses the integration fragmentation created when multiple AI applications must independently connect to multiple external tools, services, and data sources. The uploaded course material characterizes this explicitly as the N × M custom-connector problem : without a common interoperability layer, every application-to-tool pairing can require a separate integration.

The official MCP architecture supports this framing by defining a standardized client-server protocol. MCP hosts establish clients that communicate with MCP servers, while servers expose reusable capabilities such as tools, resources, and prompts. A compatible AI application therefore consumes capabilities through the MCP protocol rather than requiring a completely bespoke protocol implementation for each downstream system. MCP's tool-discovery mechanism further allows clients to obtain standardized names, descriptions, and schemas dynamically.

The problem is architectural interoperability, not GPU allocation, inference latency, or context-window limitations. Those issues require separate model, infrastructure, or prompt-management techniques. MCP instead standardizes the boundary between AI applications and external capabilities, reducing duplicated connector logic and enabling reusable integrations.

Study Guide reference/topic: Model Context Protocol (MCP) Fundamentals — interoperability, MCP client/server architecture, tool discovery, and the N × M integration problem.

===============

OCI Enterprise AI Agents provides the operational and orchestration capabilities required to run agentic applications at production scale. The uploaded course source identifies these responsibilities as hosted endpoints, runtime scaling, session management, and observability . Current Oracle documentation supports that architectural classification.

OCI Generative AI Applications provide a managed runtime for agent workloads and centralize configuration for scaling, storage, networking, authentication, and deployments. Active deployments expose managed endpoints, while autoscaling controls can increase or decrease replicas according to workload metrics. OCI's Responses API also provides conversation state, Conversations, memory, and related context-management facilities for stateful agent interaction. Operational visibility is supported through OCI metrics, monitoring, endpoint telemetry, tracing, and hosted application logs integrated with OCI Observability and Management.

Document chunking/indexing is a retrieval-processing responsibility rather than the complete agent-platform role. Prompt definition remains application logic, and OCI network routing is handled by underlying OCI networking services.

Therefore, C best represents the production responsibilities of the Enterprise AI Agents layer.

Study Guide reference/topic: OCI Enterprise AI Agents — managed runtime, deployments, autoscaling, endpoints, conversations, memory, monitoring, and observability.

===============

OCI Generative AI uses Dedicated AI Clusters to provide the isolated compute infrastructure required for fine-tuning and hosting custom model workloads. Oracle defines Dedicated AI Clusters as compute resources dedicated to a customer's models rather than shared with other tenancies. They can be created specifically for fine-tuning or for hosting model endpoints.

Oracle's current model onboarding workflow confirms the requirement. For imported models, the process includes importing the model, creating a hosting Dedicated AI Cluster , creating an endpoint, and then invoking the model. Fine-tuned models similarly require dedicated clusters for fine-tuning and subsequent hosting.

Shared On-Demand inference is appropriate for supported Oracle-hosted pretrained models, but it does not provide the dedicated isolated serving environment required by these custom model workflows. Object Storage can be an input location for model artifacts or training data, but it is storage rather than model-serving infrastructure. General-purpose Free Tier compute is likewise not the managed Generative AI capability Oracle specifies for custom-model serving.

Thus, B is correct and agrees with the uploaded course material.

Study Guide reference/topic: OCI Enterprise AI Agents — Dedicated AI Clusters, imported models, fine-tuned custom models, hosting clusters, and endpoints.

===============

The OpenAI Agents SDK uses an iterative agent loop for multi-step tool execution. In this scenario, the model first determines that it needs the multiply tool and generates a call with the arguments 15 and 8 . The application executes that tool and returns 120 as a tool result. The model receives the updated conversation state, recognizes that another operation remains, and subsequently requests divide(120, 3) . The resulting value is then available for the final response. The uploaded course source explicitly specifies this sequence.

OpenAI's Agents SDK documentation confirms that the Runner repeatedly calls the LLM, executes requested tools, appends their results, and runs the model again until final output is produced.

The Runner does not independently decide to calculate the arithmetic itself. Nor does the SDK automatically merge unrelated function calls into one synthetic operation. Likewise, an agent does not invoke every registered tool indiscriminately; the model selects the tools required by the current task.

Therefore, D accurately describes the sequential model/tool interaction.

Study Guide reference/topic: OpenAI Responses API and Agents SDK — agent loop, sequential tool calls, tool results, Runner orchestration, and multi-step execution.

===============

The distinction concerns ownership of the conversation and orchestration flow , not synchronous versus asynchronous execution. In the OpenAI Agents SDK's Manager pattern—also called agents-as-tools—a central manager remains the active user-facing agent. It invokes specialist agents as tools, receives their outputs, synthesizes them, and retains responsibility for the final response. The specialist supports the manager without taking ownership of the conversation.

A Handoff works differently. When the current agent hands the task to another agent, the selected specialist becomes the active agent and takes over the conversation for the remainder of that portion of the run. OpenAI's official Agents SDK documentation explicitly describes the Manager pattern as retaining control and Handoffs as transferring control to a specialized agent.

This distinction allows architects to select centralized orchestration when a single agent must aggregate results or apply common controls, and decentralized handoffs when specialists should directly own particular interactions. Therefore, D states the relationship correctly and matches the uploaded question's answer key.

Study Guide reference/topic: OpenAI Responses API and Agents SDK — multi-agent orchestration, Agents as Tools/Manager pattern, and Handoffs.

===============

Short-term memory compaction is a mechanism for reducing an expanding conversation history into a smaller retained representation while preserving the important information needed for subsequent turns. The uploaded source characterizes this as a summarization process for long conversations , making B the intended answer.

Oracle's current OCI Generative AI documentation states that when conversation compaction is enabled, earlier chat history is automatically condensed as a conversation grows. The purpose is to retain relevant context while lowering token usage and reducing latency. The application can continue using the same conversation ID without manually rebuilding the condensed history.

Conceptually, compaction prevents long-running conversations from continually accumulating every earlier turn verbatim. Instead, previous material is compressed into a more concise memory representation that can still inform future model calls. This is a context-management feature rather than a security masking mechanism.

It also has nothing to do with optimizing Python tool execution or improving network routing. Those belong to separate runtime and infrastructure concerns.

Therefore, B is correct.

Study Guide reference/topic: OCI Enterprise AI Agents — Conversations API, short-term memory, conversation compaction, context retention, token optimization, and latency management.

===============