Oracle Agentic AI Foundations Associate 1z0-1157-26 Exam Dumps: Updated Questions & Answers (November 2026)

OCI Enterprise AI Governance provides the control framework required to operate generative and agentic AI workloads securely in enterprise environments. Oracle defines governance as a combination of infrastructure protection, access control, network security, and runtime safety mechanisms. Key capabilities include OCI IAM policies , which determine who can access and manage Generative AI resources; Private Endpoints , which prevent model traffic from requiring public network exposure; Zero Trust Packet Routing , which introduces identity-aware network enforcement; and Guardrails , which apply safety and compliance controls to model inputs and outputs.

Oracle Guardrails specifically support mechanisms including content moderation, prompt-injection detection, and personally identifiable information detection. These controls address AI-specific operational and security risks rather than model lifecycle rollback or performance optimization.

Therefore, option D accurately expresses the purpose of Enterprise AI Governance. Model version management, runtime implementation, and latency monitoring may be operational concerns in an AI platform, but they are not the principal governance function described by OCI. The uploaded examination source also identifies D as the correct answer.

Study Guide reference/topic: OCI Enterprise AI Agents — Enterprise AI Governance, IAM, Private Endpoints, Zero Trust Packet Routing, and Guardrails.

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

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.

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

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.

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

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.

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

In MCP, STDIO is designed for local process-based communication. Under this transport, the host or client application launches the MCP server as a subprocess and exchanges protocol messages through the server's standard input ( stdin ) and standard output ( stdout ). The uploaded examination source identifies this behavior as the correct definition.

STDIO should be contrasted with Streamable HTTP , which is designed for independently running, network-accessible MCP servers and remote communication. STDIO is particularly suitable for local integrations where the MCP server executable can run on the same machine as the host application.

The transport mechanism does not change MCP's underlying message semantics. MCP communication still uses JSON-RPC structures; STDIO does not replace JSON with an unrelated plain-text protocol. Authentication requirements such as OAuth are also not an inherent requirement of STDIO. OAuth and HTTP-oriented authentication concerns primarily arise in remote server architectures.

Therefore, the defining STDIO behavior is local subprocess execution coupled with stdin/stdout message exchange.

Answer C correctly captures the architecture described by MCP and by the uploaded course source.

Study Guide reference/topic: Model Context Protocol (MCP) Fundamentals — STDIO transport, local MCP servers, subprocess lifecycle, JSON-RPC, and Streamable HTTP comparison.

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

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.

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

Oracle AI Database provides a native VECTOR data type specifically for storing vector embeddings. The uploaded course source identifies VECTOR as the correct native column type.

Oracle's official AI Vector Search documentation states that the built-in VECTOR data type provides the foundation for storing embeddings directly alongside relational business data. A table can therefore define a vector column in the same way it defines conventional Oracle columns, for example doc_vector VECTOR .

This native representation is important because Oracle AI Database can apply vector-specific SQL operations and vector indexes directly to stored embeddings. Applications can combine similarity search with relational predicates, JSON processing, graph operations, spatial queries, and standard SQL without moving embeddings into a separate specialized vector database.

Although Oracle may internally use storage mechanisms such as SecureFiles for vector representation, BLOB is not the logical SQL column type developers use for AI Vector Search embeddings . JSON and VARCHAR2 are likewise general-purpose data types and do not provide native vector semantics.

Therefore, A is correct.

Study Guide reference/topic: Agentic AI for Oracle AI Database — VECTOR data type, vector columns, embedding storage, vector indexes, and AI Vector Search.

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

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

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

Memory poisoning is an agent-security attack in which malicious, misleading, or attacker-controlled information is introduced into memory that the agent may reuse in future reasoning or actions. The uploaded course source defines it as malicious content inserted into persistent memory stores and identifies C as correct.

Oracle's current AI Agent Memory security guidance explains why persistent memory must be treated as a security-sensitive surface. Model-derived memories, summaries, context cards, metadata, and retrieved records can become persistent state and later be inserted into prompts. Oracle therefore advises treating memory-derived content as untrusted and emphasizes that write-capable memory paths can influence future prompts and retrieval results.

The broader agent-security definition is also explicit in OWASP's Agentic AI guidance: memory poisoning involves malicious data being persisted in agent memory so that it can influence future sessions or behaviors.

This differs from temporary context-window pressure, SQL injection, or physical RAM corruption. The essential security property is persistence : compromised memory can affect later reasoning long after the original malicious interaction.

Therefore, C is correct.

Study Guide reference/topic: Introduction to AI Agents — agent memory, persistent state, memory poisoning, prompt injection persistence, and agent security.

When LangChain's @tool decorator is applied to a Python function, the function's documentation becomes part of the metadata shown to the language model. LangChain explicitly states that, by default, the function's docstring becomes the tool description , helping the model understand when the capability should be selected.

This metadata is operationally significant because tool selection is model-driven. A clear description communicates the tool's purpose, appropriate usage conditions, expected arguments, and semantic boundaries. LangChain's context-engineering guidance emphasizes that tool names, descriptions, argument names, and argument descriptions guide the model's reasoning about when and how a particular tool should be invoked.

Docstrings therefore affect agent reliability, not Python runtime performance. They do not determine which underlying model provider is used, and they have no cryptographic role in protecting function parameters. Poor or ambiguous descriptions can cause an LLM to choose an inappropriate tool or supply unsuitable arguments even when the Python implementation itself is technically correct.

Consequently, D precisely captures why docstrings are particularly important for @tool -defined LangChain functions. The uploaded source confirms the same answer.

Study Guide reference/topic: LangChain for AI Agents — @tool decorator, tool descriptions, docstrings, schemas, tool selection, and context engineering.

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