1z0-1157-26 Agentic AI Foundations Associate Questions and Answers

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.

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

A basic Python implementation of the OCI Responses API uses the official OpenAI Python SDK, installed through the openai package. Oracle's Enterprise AI Agents quick-start documentation explicitly instructs developers to install it using pip install openai and further clarifies that the Responses API should be invoked using the OpenAI SDK rather than the OCI SDK.

This is possible because OCI's Responses API implements an OpenAI-compatible interface . Developers use familiar OpenAI request structures while configuring the base URL for OCI Generative AI and supplying OCI-compatible authentication. Oracle supports multiple OCI authentication approaches, including user principals, instance principals, and resource principals, while the client API retains the OpenAI-compatible programming model.

The other packages serve unrelated purposes. boto3 is the AWS SDK for Python; requests-html is an HTTP/HTML processing library; and Django is a Python web application framework. None is the required client package for the documented OCI Responses API quick-start.

Consequently, C is the correct answer and directly matches both Oracle's implementation instructions and the answer identified in the supplied examination file.

Study Guide reference/topic: OCI Enterprise AI Agents — OCI Responses API, OpenAI compatibility, Python SDK setup, endpoints, and OCI authentication.

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

Oracle AI Vector Search uses the SQL function VECTOR_DISTANCE() as its principal mechanism for computing mathematical distance between two vector representations. The function accepts two vector expressions and can optionally accept a distance metric. Oracle describes VECTOR_DISTANCE as the main vector-distance function and supports metrics appropriate to similarity-search workloads, with cosine behavior available according to the query and vector-index configuration.

Vector distance is fundamental to semantic retrieval because an embedding model represents meaning as numerical coordinates in multidimensional space. A query embedding can therefore be compared with stored embeddings, and results can be ranked according to their calculated distance. Oracle's documentation demonstrates this pattern using ORDER BY VECTOR_DISTANCE(...) to identify vectors semantically closest to the query vector.

Oracle also provides shorthand functions such as L1_DISTANCE , L2_DISTANCE , COSINE_DISTANCE , and INNER_PRODUCT , but none of the alternative names supplied in this question— VECTOR_SCORE , SCORE_SIMILARITY , or EMBEDDING_DISTANCE —is the principal Oracle SQL function being tested.

Therefore, C is unequivocally correct and matches the uploaded source answer.

Study Guide reference/topic: Agentic AI for Oracle AI Database — Oracle AI Vector Search, VECTOR_DISTANCE, distance metrics, and similarity search.

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

A standalone LLM request typically consists of supplying input and receiving model-generated output. An AI agent adds an orchestration layer that enables the model to participate in a broader execution loop. Oracle's Enterprise AI Agents architecture explicitly combines model interaction with tools, memory, conversation state, reasoning, and multi-step orchestration . Tools allow an agent to retrieve information or perform actions through File Search, Function Calling, Code Interpreter, or MCP Calling. Memory preserves relevant state within or across conversations, while iterative execution enables the agent to evaluate intermediate results and determine subsequent actions until the task is complete. These capabilities do not require changing the transformer's architecture, increasing its training speed, or providing native graphical-interface rendering. Therefore, tool access, memory handling, and iterative execution are the defining additions described by option A. Oracle Docs

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

The OpenAI Agents SDK implements an iterative agent loop in which the model determines which available capability should be invoked, receives the resulting observation, and can then make another tool call based on that updated context. Consequently, the model first requests multiply(15, 8) . The function executes and returns 120 ; that tool output is supplied back to the model. The model then determines that the remaining operation requires divide(120, 3) and requests the second tool.

OpenAI describes Agents as LLMs equipped with tools and explains that the SDK runtime manages repeated model/tool interactions until the workflow produces final output. Function tools expose schemas and executable implementations to this orchestration process.

The Runner is responsible for coordinating the loop; it does not independently substitute its own arithmetic logic for the model's tool decisions. Similarly, the SDK does not synthesize a new combined function when two distinct tools are required, nor does it invoke every available tool without reason.

The uploaded question source explicitly marks the sequential multiply-then-divide behavior as correct.

Study Guide reference/topic: OpenAI Responses API and Agents SDK — agent loop, sequential function calling, tool observations, and Runner orchestration.

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

OCI Responses API requests are associated with an OCI Generative AI Project through the project's OCID — Oracle Cloud Identifier . Oracle requires an OCI Generative AI project for agent-related OpenAI-compatible API calls and uses the project identifier to determine the project context under which responses, conversations, files, containers, retention settings, and related resources operate.

Oracle's OCI Responses API documentation shows the OpenAI client configured with a project parameter containing a Generative AI Project OCID. Oracle explicitly states that this value identifies the OCI Generative AI project for the request. Oracle's project documentation further explains that projects organize agent-specific artifacts, provide isolation boundaries, and that the project OCID must be referenced in API and SDK calls to apply project settings during runtime.

An Object Storage bucket could contain data used by another workflow but does not identify the Generative AI project. The tenancy display name identifies a tenancy conceptually but not the target project. A VCN OCID refers to network infrastructure.

Therefore, D is correct and matches the uploaded answer key.

Study Guide reference/topic: OCI Enterprise AI Agents — Generative AI Projects, Project OCID, OCI Responses API configuration, and project isolation.

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

Streamable HTTP is the standard MCP transport intended for remote or network-accessible client-server communication. Current MCP architecture documentation distinguishes it from STDIO by explaining that Streamable HTTP uses HTTP POST for client-to-server communication and can optionally use Server-Sent Events for streaming. It enables communication with remote MCP servers and can support standard HTTP authentication mechanisms.

The MCP transport specification further establishes two standard transport mechanisms: stdio and Streamable HTTP . With STDIO, the client launches an MCP server as a local subprocess and exchanges JSON-RPC messages through standard input and standard output. That pattern is therefore most appropriate for local process integration. By comparison, a Streamable HTTP server operates as an independent service and can handle multiple client connections, making it suitable for centralized or cloud-hosted MCP deployments.

Raw TCP sockets and local Unix pipes are not the standard remote MCP transport defined by the protocol. Therefore, C is correct and matches the supplied source material.

Study Guide reference/topic: Model Context Protocol (MCP) Fundamentals — STDIO versus Streamable HTTP transport and remote MCP deployment.

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

Oracle AI Vector Search defines VECTOR_DISTANCE as the primary SQL function for calculating the distance between two vectors. When the function is called without explicitly specifying a distance metric, Oracle specifies COSINE as the default metric for ordinary, non-BINARY vectors. Cosine distance measures the angular relationship between vector representations and is widely used for semantic similarity because embeddings with similar meaning tend to point in similar directions in vector space. Oracle treats BINARY vectors differently: their default metric is HAMMING. Euclidean, or L2, distance is supported but must be selected when required; it is not the general default. Levenshtein distance applies to string-edit comparisons, while bitwise XOR is not the default Oracle vector-distance metric. Therefore, for the scenario stated in the question, option C is the verified answer. Oracle Docs

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

MCP initialization establishes compatibility between the MCP client and server before normal protocol operations begin. During initialization, the parties establish a mutually supported protocol version and exchange their supported capabilities and implementation information. The client initiates the process with an initialize request containing its protocol version, capabilities, and client information. The server responds with its supported protocol version, capabilities, and server information, after which the client signals that initialization has completed. Authentication is handled at the transport or deployment security layer rather than being the defining initialization exchange. MCP initialization also does not fine-tune the LLM or execute every registered tool. This capability-negotiation process enables OCI agent applications using MCP Calling to understand which remote capabilities can safely be used. Model Context Protocol

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

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 Agents SDK separates validation at the input and output boundaries of an agent workflow. Input guardrails evaluate the initial user input, while output guardrails evaluate the final agent output before that result is accepted and returned. This makes B the intended architectural answer. A technical nuance is that current SDK input guardrails support both blocking and parallel execution: with blocking execution, validation completes before agent execution starts; with the default parallel mode, the guardrail can execute concurrently with the agent. Output guardrails, however, operate on the completed final output and always execute after the agent finishes producing it. Guardrails are runtime controls rather than decisions the LLM must explicitly request. OCI's agentic architecture similarly emphasizes governed model-and-tool workflows, making these validation boundaries important when implementing production AI agents. OpenAI GitHub

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

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.

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

StrOutputParser is a LangChain output parser used to convert a language-model response into a standard Python string. In an LCEL pipeline such as prompt | model | StrOutputParser() , the prompt prepares the model input, the model generates an AIMessage or equivalent model output, and StrOutputParser extracts the textual content so downstream application code receives plain text.

LangChain's official documentation demonstrates this exact pattern by composing a prompt, chat model, and StrOutputParser() into a chain and then invoking the resulting runnable. The parser therefore operates after model inference ; it does not send the request to the model and does not maintain agent or tool history.

The uploaded source presents the chain fragment across separate lines and explicitly identifies “It extracts plain text from the model response” as the correct response.

This output-parsing stage is especially useful because it isolates application code from provider-specific response-object structures and provides a predictable string output from a LangChain runnable.

Study Guide reference/topic: LangChain for AI Agents — LCEL chains, Runnable composition, model output handling, and StrOutputParser.

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