Oracle Cloud Generative AI Agents Tutorial: Architecture, Pricing, Use Cases, and Hands-On Guide for Analytics and AI

1. Introduction

What this service is

Generative AI Agents in Oracle Cloud is a managed way to build and run “agentic” generative AI experiences—applications that do more than answer a prompt. An agent can follow instructions, use curated knowledge, and (depending on your configuration and what Oracle supports in your region) call tools or services to complete multi-step tasks.

One-paragraph simple explanation

If you want a chat-style assistant for your company (HR policy helper, IT support assistant, finance Q&A, product documentation bot) that answers using your documents and behaves consistently, Generative AI Agents provides a structured service to configure that assistant and operate it in Oracle Cloud instead of stitching everything together from scratch.

One-paragraph technical explanation

At a technical level, Generative AI Agents sits in the Oracle Cloud (OCI) Analytics and AI portfolio and is designed to orchestrate LLM inference together with common agent building blocks (instructions, conversation context, and knowledge retrieval). In most architectures, your enterprise content lands in an OCI data source (often Object Storage and/or a database), is retrieved at query time (RAG-style patterns), and is then provided as grounded context to an LLM. The service aims to reduce the amount of custom glue code required to manage these agent workflows and deployments. Verify the exact feature set and UI/API terms in the official docs for your region, because agent capabilities evolve quickly.

What problem it solves

Teams typically struggle with: – Building a secure, repeatable, governed pattern for internal “enterprise chat” assistants – Grounding answers in authoritative documents (reducing hallucinations) – Managing identity, access, logging, and operational visibility in production – Controlling cost drivers (tokens, retrieval, storage, throughput) at scale

Generative AI Agents is intended to address those problems by providing a managed service approach aligned with OCI security and operations.

2. What is Generative AI Agents?

Official purpose

Generative AI Agents in Oracle Cloud is intended to help you create, configure, and operate generative AI “agents” that can respond to user prompts in a controlled way—often by combining: – LLM inference – Optional knowledge retrieval from your data (RAG) – Optional tool/action execution (where supported)

Because Oracle’s naming and packaging can change, you may see Generative AI Agents represented as a standalone service entry or as a capability within OCI’s broader Generative AI offerings. Verify the current product page and documentation for the exact scope in your tenancy and region.

Core capabilities (conceptual, confirm specifics in docs)

Common agent capabilities typically include: – Agent instructions / persona: define behavior and tone for consistent responses – Knowledge grounding: use enterprise documents as context for answers – Conversation handling: multi-turn chat context and session-like interactions – Safety controls: content filtering / refusal behavior (capabilities vary—verify) – Deployment and operations: environments, access control, logging/metrics (verify)

Major components (conceptual mapping)

Depending on the OCI implementation you have access to, you can expect some combination of:

Component	What it represents	Why it exists
Agent configuration	The “definition” of your agent (instructions, model choice, knowledge settings)	Makes behavior reproducible and governable
Knowledge source(s)	Documents/data used for grounding	Improves accuracy and reduces hallucination risk
Runtime / endpoint	Where requests are processed	Enables integration with apps and channels
Identity & access	IAM policies, compartments, groups	Controls who can create/use agents
Observability	Logs, metrics, audit events	Required for production operations

Verify the exact component names (for example, whether OCI uses terms like “knowledge base”, “data source”, “agent deployment”, or “endpoint”) in official docs.

Service type

Generative AI Agents is a managed cloud service (PaaS-style) within Oracle Cloud in the Analytics and AI category. You configure agents; Oracle runs the underlying infrastructure for agent execution.

Scope: regional/global/zonal and tenancy scoping

OCI AI services are typically: – Tenancy-scoped for billing and governance – Compartment-scoped for resource organization and IAM boundaries – Regional in where the service endpoint and data processing occur

However, availability and exact scoping can vary. Confirm regional availability and data residency behavior in official docs for Generative AI Agents.

How it fits into the Oracle Cloud ecosystem

Generative AI Agents is most often used alongside: – OCI Generative AI / foundation model access (for LLM inference) – OCI Object Storage (for document storage and ingestion pipelines) – OCI Logging / Monitoring / Audit (operations and governance) – OCI API Gateway + Functions (secure app integration patterns) – Oracle Autonomous Database / Oracle Database (enterprise data sources) – Oracle Integration Cloud (workflow automation and connectors) – Oracle Analytics Cloud (analytics experiences powered by governed data)

3. Why use Generative AI Agents?

Business reasons

Faster time-to-value: standard patterns for deploying internal assistants
Consistency: centrally managed instructions and behavior reduce “random” assistant output
Knowledge enablement: employees get answers faster from trusted docs
Support deflection: reduce load on IT/helpdesk and shared services teams

Technical reasons

Managed orchestration: less custom code for prompt routing, retrieval, context assembly, and session handling (verify exact orchestration capabilities)
OCI-native governance: compartments, IAM policies, tagging, and auditability
Integration-friendly: works well with common OCI building blocks (API Gateway, Functions, OKE, Object Storage)

Operational reasons

Production posture: logging, monitoring, and access controls can be aligned with established OCI ops processes
Standardization: reusable agent patterns across teams reduce duplicated effort
Change management: agent configuration updates can be controlled and reviewed

Security/compliance reasons

IAM-based access control: aligns with OCI identity governance
Audit trails: OCI Audit can record API actions (verify event coverage for agent actions)
Data residency: regional deployment helps meet locality requirements (verify actual processing locations and subprocessor details)

Scalability/performance reasons

Service-managed scaling: you avoid running your own GPU fleet for typical agent workloads
Elasticity: scale usage with demand; align cost with actual consumption

When teams should choose it

Choose Generative AI Agents when: – You need a chat/assistant-style interface grounded in enterprise knowledge – You want an OCI-governed approach (IAM/compartments/logging/audit) – You prefer managed operations over building an agent framework from scratch – You can accept the service’s model availability, quotas, and regional constraints

When they should not choose it

Consider alternatives when: – You must run fully offline / on-prem only with no cloud processing – You need full control over the entire agent runtime (custom tool routing, custom vector DB logic, specialized model hosting) and OCI’s managed approach is too constrained – Your workload requires deterministic pipelines where LLM variability is unacceptable – You have strict requirements that demand features not currently available (for example, private endpoints, specific compliance attestations, or specific model families)—verify in official docs

4. Where is Generative AI Agents used?

Industries

Financial services (policy Q&A, internal procedure assistants)
Healthcare (knowledge assistants for internal SOPs; ensure PHI controls)
Retail/e-commerce (product and operations documentation assistants)
Manufacturing (maintenance and safety manual Q&A)
Public sector (citizen service scripts, internal policy assistants)
Education (course content Q&A, student support assistants)

Team types

Platform engineering teams building an “AI platform” on OCI
Data/analytics teams enabling natural-language access to curated data
Application teams embedding assistants into internal portals
Security and compliance teams implementing governance patterns
Support/helpdesk teams improving ticket triage and resolution

Workloads

Document Q&A and enterprise search augmentation
Internal policy assistants and onboarding bots
IT runbook assistants (SRE knowledge helper)
Customer support draft responses (human-in-the-loop)

Architectures

“Chat UI → API → Agent → LLM + Knowledge → Response”
“Ticketing system → Agent → suggested resolution → human approval”
“Portal application → Agent endpoint → audit + logs → dashboards”

Real-world deployment contexts

Intranet assistants for employees
Secure SaaS products embedding a tenant-isolated assistant
Contact center workflows (with strict guardrails and approvals)

Production vs dev/test usage

Dev/test: small document sets, strict spending limits, test tenants/compartments, rapid iteration
Production: curated knowledge pipelines, change control, monitoring/SLOs, cost guardrails, IAM least privilege, incident response processes

5. Top Use Cases and Scenarios

Below are realistic scenarios for Oracle Cloud Generative AI Agents. For each, treat the exact supported connectors/actions as “verify in official docs,” because integrations evolve.

1) HR Policy Assistant

Problem: Employees ask repetitive HR questions; answers must match policy documents.
Why this service fits: An agent can be grounded in HR policy docs and consistently cite the correct policy sections (if citations are supported—verify).
Example: “How many carryover vacation days do I have?” → agent responds based on the current HR handbook and links to the authoritative PDF.

2) IT Helpdesk Triage Assistant

Problem: Tickets come in with incomplete details; triage takes time.
Why this service fits: The agent can ask clarifying questions and suggest runbook steps grounded in internal SOPs.
Example: New ticket “VPN not working” → agent asks OS type, error code, last successful login, and suggests troubleshooting steps.

3) SRE Runbook Assistant

Problem: On-call engineers need quick access to runbooks during incidents.
Why this service fits: Grounding in runbooks reduces time-to-mitigation.
Example: “High 5xx on API service” → agent suggests the correct runbook, checks and remediation steps, and escalation paths.

4) Finance Close Process Helper

Problem: Monthly close has many steps and dependencies; new hires struggle.
Why this service fits: The agent can guide step-by-step processes grounded in finance SOP docs.
Example: “What’s the deadline for AR reconciliation?” → agent answers from the current close calendar.

5) Engineering Documentation Chat

Problem: Developers can’t find the right internal docs quickly.
Why this service fits: RAG-based assistants improve discovery without migrating docs into a new system.
Example: “How do I request a new OCI compartment?” → agent points to the internal procedure and required approvals.

6) Security Policy and Exception Request Assistant

Problem: Security teams receive repetitive questions; responses must be precise.
Why this service fits: Agent can be grounded in security standards and exception workflows.
Example: “Can we open port 22 to the internet?” → agent explains the policy and the exception process.

7) Customer Support Draft Response Assistant (Human-in-the-loop)

Problem: Agents need fast, consistent draft responses.
Why this service fits: The assistant drafts responses grounded in KB articles; humans approve before sending.
Example: Customer asks about billing refunds → assistant drafts a response referencing the correct policy article.

8) Product Specification Assistant for Sales Engineers

Problem: Sales engineers need accurate technical specs quickly.
Why this service fits: Ground the agent in current product spec sheets and release notes.
Example: “Does version X support feature Y?” → agent references the latest release note entry.

9) Internal Training / Onboarding Assistant

Problem: New hires ask repetitive onboarding questions.
Why this service fits: Grounded answers reduce inconsistent guidance.
Example: “How do I set up MFA and request VPN?” → agent lists steps from onboarding docs.

10) Procurement and Vendor Policy Assistant

Problem: Employees don’t know procurement thresholds and required approvals.
Why this service fits: Ground in procurement policy and approval matrices.
Example: “Do I need 3 quotes for a $15k purchase?” → agent answers based on policy.

11) Compliance Evidence Assistant

Problem: Audit requests require collecting evidence from many documents.
Why this service fits: Agent can guide where evidence typically lives and what is acceptable (do not let it fabricate evidence).
Example: “Show password policy evidence” → assistant lists the system settings export and policy doc locations.

12) Multi-lingual Internal Knowledge Assistant (If supported)

Problem: Global workforce needs consistent answers in multiple languages.
Why this service fits: If the underlying models support multilingual output, an agent can respond in requested language while grounding in canonical docs.
Example: Employee asks in Spanish; agent answers in Spanish but cites English policy section.

6. Core Features

Because Generative AI Agents evolves rapidly, the feature descriptions below focus on commonly expected agent-service behaviors and OCI operational patterns. Confirm each feature’s availability and exact configuration steps in the official Oracle Cloud documentation for Generative AI Agents in your region.

1) Managed agent configuration

What it does: Lets you define the agent’s behavior and settings as a managed cloud resource.
Why it matters: You can standardize assistants across teams and environments.
Practical benefit: Repeatable deployments; simpler governance vs. ad-hoc scripts.
Limitations/caveats: Configuration options vary (model selection, max tokens, retrieval settings, etc.). Verify what’s exposed.

2) System instructions / persona controls

What it does: Sets the assistant’s role, allowed behavior, tone, and boundaries.
Why it matters: Reduces risky outputs and improves consistency.
Practical benefit: “Answer only from approved knowledge; if not found, say you don’t know.”
Caveats: Instructions are not absolute guarantees; you still need guardrails and evaluation.

3) Knowledge grounding (RAG-style retrieval)

What it does: Retrieves relevant snippets from approved sources and uses them as context for the LLM.
Why it matters: Reduces hallucination and keeps answers aligned with your policies.
Practical benefit: Higher accuracy for enterprise Q&A.
Caveats: Retrieval quality depends on document quality, chunking/indexing, and query formulation. Also, grounding does not eliminate all hallucinations.

4) Conversation context handling

What it does: Supports multi-turn interactions where previous turns influence responses.
Why it matters: Most assistants are conversational, not single-shot.
Practical benefit: “Continue from last step” workflows.
Caveats: Context windows are limited; long chats can cause truncation or increased token costs.

5) Model selection and configuration (dependent on OCI offering)

What it does: Uses OCI-supported foundation models for inference.
Why it matters: Different models optimize for cost, latency, reasoning, or context size.
Practical benefit: Choose cheaper models for simple Q&A stronger models for complex tasks.
Caveats: Model availability is region-dependent; some models may have usage restrictions.

6) Integration patterns with OCI services

What it does: Enables common integration architectures using OCI API Gateway, Functions, OKE, Object Storage, and IAM.
Why it matters: Enterprise apps need secure access paths and controlled egress.
Practical benefit: Put an API layer in front of the agent; enforce auth, throttling, and logging.
Caveats: Some AI services are accessed via public endpoints; private networking options vary—verify.

7) IAM, compartments, tagging

What it does: Uses OCI IAM and compartment scoping for admin/user separation; resource tags for cost allocation.
Why it matters: Production AI requires governance.
Practical benefit: Separate dev/test/prod compartments; apply tags for chargeback.
Caveats: Least-privilege policy design requires careful testing; start from Oracle’s published policy examples.

8) Observability hooks (logs/metrics/audit)

What it does: Leverages OCI’s logging/monitoring/audit ecosystem to support operations.
Why it matters: You need to troubleshoot latency, failures, and unexpected costs.
Practical benefit: Create dashboards and alerts for error rates and usage spikes.
Caveats: The exact metrics/log fields depend on the service—verify what is emitted and whether prompt/response content is logged (and how to control that).

7. Architecture and How It Works

High-level architecture

A typical Oracle Cloud Generative AI Agents architecture includes: 1. A client (web app, internal portal, mobile app, or CLI tool) 2. An API layer (optional but recommended for production) to enforce auth, quotas, and request validation 3. The Generative AI Agents service to orchestrate agent behavior 4. Knowledge sources (documents/data) for grounding 5. Observability and governance (Logging, Monitoring, Audit, tags)

Request/data/control flow (typical)

User sends a prompt to your app.
Your app calls an API (API Gateway / backend service).
Backend authenticates user and applies rate limits and policy checks.
Backend calls Generative AI Agents in a specific OCI region.
Agent runtime may retrieve relevant context from configured knowledge sources (RAG pattern).
LLM generates a response using agent instructions and retrieved context.
Response returns to the user; logs/metrics/audit are recorded per OCI settings.

Integrations with related OCI services

Common building blocks: – OCI Object Storage: store documents, policies, manuals, KB exports – Oracle Autonomous Database: curated Q&A tables, metadata, entitlements – OCI Functions: post-processing, workflow triggers, tool-like actions (if you implement them) – OCI API Gateway: authentication, throttling, WAF-like patterns, routing – OCI Vault: secrets for downstream systems – OCI Logging/Monitoring/Audit: operational insights and governance – OCI Identity and Access Management (IAM): least privilege access

Dependency services

At minimum, agent solutions often depend on: – An OCI region where Generative AI Agents is available – OCI IAM and compartments – A knowledge repository (Object Storage and/or database) – Client/app hosting (Compute, OKE, Functions, or external)

Security/authentication model

OCI services typically support: – User-based auth via OCI Console for administrators – API auth via OCI request signing (SDK/CLI) for applications – Instance principals or resource principals for workloads running on OCI

The recommended production approach is: – Run your backend on OCI and use instance principals / resource principals – Avoid embedding long-lived keys in code – Put API Gateway in front of your backend for external clients

Networking model

Many OCI AI services are accessed via regional public endpoints. Some OCI services support private endpoints or VCN integration; verify whether Generative AI Agents supports private endpoints in your region. If it’s public: – Use outbound controls (NAT, egress allowlists where possible) – Restrict which services can call the agent (IAM + API Gateway) – Avoid direct browser-to-agent calls from untrusted networks

Monitoring/logging/governance considerations

Decide what to log (requests, metadata, latency, errors) while minimizing sensitive content.
Use Audit for administrative actions and changes.
Tag resources for cost allocation: CostCenter, Environment, Owner, DataSensitivity.

Simple architecture diagram (Mermaid)

flowchart LR
  U[User] --> A[App / Portal]
  A --> B[Backend API]
  B --> G[Generative AI Agents (OCI Region)]
  G --> K[Knowledge Source (Object Storage / DB)]
  G --> R[LLM Inference (OCI Generative AI)]
  B --> L[OCI Logging/Monitoring]

Production-style architecture diagram (Mermaid)

flowchart TB
  subgraph Client
    W[Web UI / Internal Portal]
    C[CLI / Integrations]
  end

  subgraph Edge["OCI Edge (Recommended)"]
    APIG[OCI API Gateway]
    WAF[Optional: Edge protections / policies]
  end

  subgraph AppTier["App Tier (VCN)"]
    SVC[Agent Orchestrator Service\n(OKE/Compute/Functions)]
    VAULT[OCI Vault]
  end

  subgraph AI["Analytics and AI (OCI Region)"]
    AG[Generative AI Agents]
    LLM[LLM / Generative AI Inference]
  end

  subgraph Data["Data Sources"]
    OS[OCI Object Storage\nDocuments]
    ADB[Autonomous Database\nMetadata/Entitlements]
  end

  subgraph Ops["Operations & Governance"]
    LOG[OCI Logging]
    MON[OCI Monitoring/Alarms]
    AUD[OCI Audit]
  end

  W --> APIG
  C --> APIG
  APIG --> SVC
  SVC --> AG
  AG --> LLM
  AG --> OS
  AG --> ADB

  SVC --> VAULT
  APIG --> LOG
  SVC --> LOG
  AG --> LOG
  LOG --> MON
  AG --> AUD
  APIG --> AUD
  SVC --> AUD

8. Prerequisites

Tenancy/account requirements

An active Oracle Cloud tenancy with billing enabled (or an approved internal account).
Access to an OCI region where Generative AI Agents is available. Availability varies by region—verify in official docs.

Permissions / IAM roles

For the hands-on lab, the simplest approach is: – Use a user that is a tenancy administrator, or – Use a user with broad management permissions in a dedicated lab compartment

For production, you should implement least privilege: – Separate “agent admins” (create/update agents, manage knowledge) – From “agent users” (invoke agent runtime endpoints) – And from “ops/security” (view logs/audit, manage alerts)

Important: OCI IAM policy syntax and resource families are service-specific. Use the official Generative AI Agents IAM policy examples from Oracle docs to avoid trial-and-error.

Billing requirements

Expect usage-based charges for LLM inference and any retrieval/indexing components (details in the next section).
Ensure budgets and alerts are configured before production rollouts.

CLI/SDK/tools needed (recommended)

OCI Console access
OCI CLI (optional but useful): https://docs.oracle.com/en-us/iaas/Content/API/SDKDocs/cliinstall.htm
A workstation with:
Python 3.x (optional, for integration testing)
curl (optional)

Region availability

Confirm that your selected OCI region supports Generative AI Agents and the models you plan to use.
Plan for data residency: store knowledge sources in the same region when required.

Quotas/limits

Expect service limits such as: – Requests per minute – Concurrent sessions – Max prompt/context length – Knowledge base size / number of documents – Max document size

These limits vary—verify in official docs and your tenancy service limits.

Prerequisite services

For the lab in this tutorial, you’ll use: – OCI Object Storage (to store the documents used for grounding) – OCI Logging/Audit (for basic governance) – Generative AI Agents (the main service)

9. Pricing / Cost

Do not treat this section as a quote. OCI pricing is region-dependent and can change. Some organizations also have negotiated rates. Always validate using the official Oracle pricing pages and the OCI cost estimator/calculator.

Current pricing model (how it’s typically structured)

For Generative AI Agents, costs usually come from a combination of:

Model inference usage – Typically priced by tokens (input tokens + output tokens) or similar consumption metrics. – Different models have different rates.
Knowledge grounding / retrieval costs (if applicable) – If the service builds or uses embeddings/vector indexes, you may pay for:
- Embedding generation (token-based or unit-based)
- Index storage
- Retrieval operations
Data storage – Object Storage for source documents (GB-month) – Possible additional storage for indexes/derived artifacts (service-dependent)
Networking – Ingress is often free; egress can be charged, especially to the public internet or other regions. – Inter-service traffic patterns matter in distributed deployments.
Operational services – Logging ingestion and retention costs (depending on volume and retention settings) – Monitoring metrics (usually low cost but can add up at scale) – API Gateway requests (if used)

Free tier

Oracle has a Free Tier program for some OCI services, but Generative AI Agents and/or the underlying model inference may not be included or may have limited promotions. Verify eligibility and limits: – https://www.oracle.com/cloud/free/

Cost drivers (what makes bills grow)

High chat volume (requests/day)
Long prompts and long answers (token growth)
Large context windows and multi-turn conversations
Retrieval that includes many chunks/snippets per answer
Frequent re-indexing or ingestion of documents
Logging too much content (prompt/response bodies) at high volume
Cross-region architectures causing egress charges

Hidden or indirect costs

Document pipelines: OCR, parsing, chunking, cleanup (compute + storage)
Evaluation environments: test traffic can double usage if unmanaged
Security layers: API Gateway, WAF patterns, additional logging retention
Human review: operational overhead for safety and correctness

Network/data transfer implications

Keep the app tier and agent service in the same region when possible.
Avoid sending large documents inline; store in Object Storage and reference them.
If users are global, consider caching and routing strategies.

How to optimize cost

Use the smallest model that meets quality requirements.
Constrain response length (where supported).
Apply retrieval limits: fewer chunks, stricter similarity thresholds (where supported).
Use summaries for long documents rather than passing full text repeatedly.
Implement rate limits and quotas by user/team.
Avoid logging full prompts/responses unless required; log metadata instead.

Example low-cost starter estimate (non-numeric, model-based)

A realistic “starter” environment typically includes: – A small Object Storage bucket (tens to hundreds of MB of documents) – A single agent used by a small team – Limited daily request volume – Conservative max output length – Logging configured for metadata, with short retention

Your cost will mainly be driven by inference tokens and any embedding/indexing. Use Oracle’s pricing pages to plug in token volumes and expected traffic.

Example production cost considerations

For production, plan for: – Separate dev/test/prod environments (each with usage) – Higher concurrency and peak-hour scaling – More documents and frequent updates – Stronger models for complex workflows – Monitoring, alerting, longer log retention, and audit review processes

Official pricing resources (start here)

Oracle Cloud pricing overview: https://www.oracle.com/cloud/pricing/
OCI cost estimator: https://www.oracle.com/cloud/costestimator.html
Oracle Cloud Free Tier: https://www.oracle.com/cloud/free/
OCI documentation landing page (use this to navigate to Generative AI Agents pricing references): https://docs.oracle.com/en-us/iaas/

Tip: In practice, Oracle’s AI pricing is often listed under AI/ML or Generative AI sections on the price list. Use the pricing pages to locate the exact SKUs for your model/provider and region.

10. Step-by-Step Hands-On Tutorial

This lab focuses on a low-risk, beginner-friendly deployment pattern: create a small knowledge set in Object Storage and configure a Generative AI Agents assistant to answer questions grounded in those documents.

Because OCI consoles and AI features can change, follow the official Generative AI Agents “Getting Started” guide in parallel and adjust any menu names accordingly.

Objective

Create a Generative AI Agents assistant in Oracle Cloud that answers questions about a small set of internal policy documents stored in OCI Object Storage, and validate that the agent refuses or defers when the answer is not present in the documents.

Lab Overview

You will: 1. Create a dedicated OCI compartment for the lab. 2. Create an Object Storage bucket and upload a couple of small text/markdown documents. 3. Configure Generative AI Agents to use those documents as a knowledge source (grounding). 4. Test the agent in the console (or the official testing tool provided by Oracle). 5. Validate grounding behavior with positive and negative queries. 6. Clean up all created resources.

Step 1: Create a dedicated compartment (recommended)

Goal: isolate resources for easy cleanup and clearer IAM boundaries.

In the OCI Console, open the navigation menu.
Go to Identity & Security → Compartments.
Click Create Compartment.
Use: – Name: genai-agents-lab – Description: Lab resources for Generative AI Agents tutorial
Click Create Compartment.

Expected outcome – A new compartment genai-agents-lab exists and is selectable throughout the console.

Verification – Select the compartment in the top-left compartment selector and confirm it appears.

Step 2: Ensure you have permissions

Goal: ensure your user can create Object Storage resources and Generative AI Agents resources.

For a beginner lab: – Use a tenancy admin account, or – Use an account that already has “manage all resources” permissions in the genai-agents-lab compartment.

Expected outcome – You can create buckets and access Generative AI Agents pages without authorization errors.

Verification – Try navigating to Object Storage (next step). If you see authorization errors, stop and fix IAM.

Notes for production – Do not use broad admin permissions in production. – Use Oracle’s official IAM policy examples for Generative AI Agents to implement least privilege.

Step 3: Create an Object Storage bucket

Goal: store the documents your agent will use for grounding.

Go to Storage → Object Storage & Archive Storage → Buckets.
Select compartment: genai-agents-lab.
Click Create Bucket.
Configure: – Bucket name: genai-agents-knowledge – Default storage tier: Standard – Encryption: Oracle-managed keys (default) unless you require customer-managed keys
Click Create.

Expected outcome – Bucket genai-agents-knowledge is created.

Verification – Open the bucket and confirm it shows an empty object list.

Step 4: Create sample documents and upload them

Goal: provide a small but realistic knowledge set.

Create two local files on your workstation:

leave-policy.md

# Leave Policy (Sample)

Employees receive 20 days of paid time off (PTO) per calendar year.
Up to 5 unused PTO days may be carried over into the next year.
Sick leave is separate from PTO and provides 10 days per year.

For HR questions, contact hr@example.com.

vpn-troubleshooting.md

# VPN Troubleshooting (Sample)

If VPN login fails:
1. Confirm your MFA is enabled.
2. Verify your password was changed within the last 90 days.
3. If you see "certificate expired", reinstall the VPN client and re-download the profile.
4. If the error persists, open an IT ticket with the full error text and timestamp.

Escalation: On-call network engineer after 30 minutes of outage impact.

Upload via console: 1. Open your bucket genai-agents-knowledge. 2. Click Upload. 3. Upload both leave-policy.md and vpn-troubleshooting.md.

Expected outcome – Two objects appear in the bucket.

Verification – Click each object and confirm size and content preview (if available).

Optional: upload via OCI CLI If you prefer CLI (and you have OCI CLI configured), use:

# Verify your CLI is configured
oci os ns get

# Create the bucket (if you didn't do it in console)
oci os bucket create --name genai-agents-knowledge --compartment-id <your_compartment_ocid>

# Upload files
oci os object put --bucket-name genai-agents-knowledge --file leave-policy.md
oci os object put --bucket-name genai-agents-knowledge --file vpn-troubleshooting.md

If you use CLI, you must supply your compartment OCID; get it from the compartment details page.

Step 5: Create/configure a Generative AI Agents assistant

Goal: create an agent that is instructed to answer only from the uploaded docs.

Navigate to Analytics and AI → Generative AI Agents (exact menu path may vary—verify in your console).
Select compartment: genai-agents-lab.
Click Create (agent).
Configure the agent with: – Name: policy-helper-agent – Instructions (system prompt style):
- “You are an internal assistant. Answer questions using only the provided knowledge sources. If the answer is not in the documents, say you don’t know and suggest who to contact.”
Configure the knowledge source: – Choose Object Storage bucket genai-agents-knowledge – Select the objects (or the bucket/prefix) containing the documents
Choose a model (if prompted): – Select an OCI-supported model available in your region. – Prefer a smaller/cheaper model for the lab if quality is acceptable.
Create the agent.

Expected outcome – The agent policy-helper-agent exists and shows as “Active/Ready” (terminology varies).

Verification – Open the agent details page and confirm: – Instructions are saved – Knowledge source references your bucket/documents – Status indicates it can be tested

Important note – Some services require an indexing/ingestion step before the knowledge is searchable. If you see an “ingestion” or “sync” workflow, run it and wait for completion.

Step 6: Test the agent in the console

Goal: verify grounded answers and “don’t know” behavior.

Use the built-in test/chat interface for the agent (naming varies: “Playground”, “Chat”, “Test”, etc.).

Run these prompts:

Grounded question (should answer from doc): – Prompt: How many PTO days do employees get per year? – Expected: 20 days (or equivalent wording)
Carryover question: – Prompt: How many PTO days can I carry over? – Expected: Up to 5 days
VPN runbook question: – Prompt: What should I do if VPN login fails with a certificate expired error? – Expected: reinstall VPN client and re-download profile (from doc)
Negative test (not in docs): – Prompt: What is the company’s parental leave policy? – Expected: agent should say it does not know based on provided documents and suggest contacting HR (as instructed)

Expected outcome – The agent answers correctly for the first three prompts. – For the fourth, it refuses to invent a policy and follows the “only from docs” instruction.

Step 7: Add an operational wrapper (recommended pattern)

Goal: avoid direct end-user access to the agent service and implement governance.

Even if you don’t build it fully in this lab, understand the recommended production approach: – Put a backend service in front of the agent – Authenticate users (SSO/OIDC) – Enforce rate limits and record audits – Optionally implement per-user entitlements (who can ask what)

Expected outcome – Clear next step for production hardening.

Verification – Document your chosen access pattern (API Gateway + Function/OKE service) for later implementation.

Validation

Use this checklist:

Check	How to validate	Pass criteria
Agent exists	Agent details page	Status indicates ready
Knowledge connected	Agent knowledge settings	Shows Object Storage source and docs
Grounded Q&A works	Ask PTO/VPN questions	Answers match docs
Hallucination resistance	Ask unknown policy	Agent says it doesn’t know
Cost awareness	Review usage/metrics (if exposed)	No unexpected high usage

Troubleshooting

Problem: “Not authorized” when creating agent or bucket – Cause: IAM policy missing or wrong compartment selected. – Fix: use a tenancy admin for the lab, or apply correct policies per official docs.

Problem: Agent can’t find answers that are in the docs – Causes: – Ingestion/indexing not complete – Document format not supported – Very small docs sometimes chunk oddly; try adding more context – Fixes: – Re-run ingestion/sync – Convert to a supported format (txt/markdown is typically simplest) – Expand the doc and use clearer headings

Problem: Agent answers beyond the docs – Causes: – Instructions not strict enough – Service may not support strict “knowledge-only” enforcement in all modes – Fixes: – Strengthen system instructions: “If not explicitly present, say ‘I don’t know’.” – Add evaluation tests and human review for production – Check whether there are “grounding required” options (verify in docs)

Problem: High latency – Causes: – Large context retrieval – Larger model – Regional load – Fixes: – Use a smaller model – Reduce retrieved snippets/chunks (if configurable) – Keep your app and documents in the same region

Cleanup

To avoid ongoing charges, delete resources:

Delete the Generative AI Agents agent policy-helper-agent.
Delete the Object Storage objects in genai-agents-knowledge.
Delete the bucket genai-agents-knowledge.
(Optional) Delete the compartment genai-agents-lab (only if it contains nothing else).

Verification – Confirm the bucket no longer exists. – Confirm the agent is deleted. – Review billing/usage dashboards after some time to ensure no ongoing usage.

11. Best Practices

Architecture best practices

Use API Gateway + backend in front of Generative AI Agents for production.
Keep data sources and agent endpoints in the same OCI region when possible.
Implement RAG with curated documents rather than letting the LLM answer from general knowledge for policy-critical use cases.
Maintain a documented lifecycle: dev → test → prod, with gated promotion.

IAM/security best practices

Use compartments to separate environments and teams.
Implement least privilege:
Admins can create/update agents and knowledge sources
Applications can invoke runtime endpoints
Users only interact through your app, not directly to service APIs
Prefer instance principals / resource principals over user API keys.

Cost best practices

Start with smaller models for basic Q&A upgrade only when quality requires it.
Set response limits and retrieval constraints (where supported).
Avoid logging full prompt/response bodies unless necessary.
Tag every resource with Environment, Owner, CostCenter, Project.

Performance best practices

Keep documents clean and well-structured (headings, short sections).
Avoid huge “mega documents”; split into topic-based files.
Cache frequent questions and responses in your app layer where allowed.

Reliability best practices

Implement retries with backoff for transient errors (in your backend).
Use circuit breakers to protect upstream systems.
Provide fallback behaviors: show “I can’t answer right now” with escalation links.

Operations best practices

Define SLOs (latency, error rate) and set alarms.
Capture request IDs and correlate logs across API Gateway → backend → agent calls.
Review changes to agent instructions/knowledge as a controlled change process.

Governance/tagging/naming best practices

Use consistent naming:
genai-agents-<env>-<purpose>
Apply tag defaults at compartment level (where your governance model supports it).
Maintain an inventory of agents, owners, and allowed data sources.

12. Security Considerations

Identity and access model

OCI IAM governs who can:
Create/update/delete agents
Manage knowledge sources
Invoke agent runtime APIs (if exposed)
Production recommendation:
Users authenticate to your app via SSO
Only your backend calls the agent service using workload identity

Encryption

Use OCI default encryption at rest for Object Storage.
If required, use customer-managed keys via OCI Vault (verify support for every resource type you use).
Ensure TLS is used in transit (standard for OCI service endpoints).

Network exposure

Avoid direct public client access to agent endpoints.
Use API Gateway and private app tiers.
Restrict egress paths for workloads making service calls.

Secrets handling

Store secrets in OCI Vault, not in code or environment variables in plaintext.
Rotate secrets and keys.
Prefer identity-based auth (principals) instead of static secrets.

Audit/logging

Enable and review OCI Audit for administrative actions.
Configure Logging retention to meet policy but avoid retaining sensitive content longer than necessary.
Decide whether prompt/response bodies are logged. If you must log them, apply redaction/tokenization upstream.

Compliance considerations

Data privacy: do not upload sensitive regulated data unless you have validated Oracle’s service terms, region processing, and your compliance obligations.
Data residency: keep documents and processing in compliant regions.
Model risk management: establish testing, monitoring, and human oversight for high-impact decisions.

Common security mistakes

Letting end users call agent APIs directly with broad credentials
Overly permissive IAM policies in production
Uploading secrets (passwords, API keys) into knowledge documents
Logging raw prompts/responses containing sensitive data
Treating LLM outputs as authoritative without verification

Secure deployment recommendations

“Trust-but-verify” outputs: require citations or references for policy-critical answers (if supported).
Human-in-the-loop for external communications or high-risk workflows.
Continuous evaluation: regression tests for new documents and instruction changes.

13. Limitations and Gotchas

Because this service evolves, verify current limits in Oracle’s official docs. Common limitations to plan for:

Known limitations (typical)

Region availability: not all regions support the service or all models.
Model availability: model families vary by region and may change.
Context window limits: long conversations can exceed context size.
Document format constraints: some file types may not parse well.
Strict grounding is hard: instruction-only controls can fail; you must test.

Quotas

Requests per minute / concurrency
Maximum knowledge items or total size
Maximum response length

Regional constraints

Data residency requirements may force single-region deployment.
Cross-region calls can introduce latency and egress cost.

Pricing surprises

Token usage grows quickly with long prompts, large retrieved contexts, and verbose answers.
Re-indexing/ingestion can be a cost spike (if billed separately).

Compatibility issues

Some enterprise documents require OCR or preprocessing.
Tables and scanned PDFs can degrade retrieval quality.

Operational gotchas

Without an API wrapper, you may struggle to implement:
per-user rate limits
entitlements
consistent logging and redaction
Teams often forget to clean up test agents and indexing artifacts.

Migration challenges

If you move from a self-managed agent framework to Generative AI Agents:
prompt/instruction tuning will differ
retrieval chunking and ranking may differ
evaluations must be redone

Vendor-specific nuances

OCI IAM and compartment design matters a lot for governance.
Observability depends on OCI Logging/Audit configuration and service emission specifics.

14. Comparison with Alternatives

Within Oracle Cloud (nearest options)

OCI Generative AI (foundation model inference): Use directly if you want to build your own agent orchestration in code.
OCI Data Science: Better for custom ML training, notebooks, pipelines, and model ops (not specifically “agent configuration”).
Oracle Digital Assistant: A separate product area for conversational experiences; suitability depends on your needs and Oracle’s current feature set (verify current positioning).

In other clouds (nearest equivalents)

AWS: Amazon Bedrock Agents
Azure: Azure AI Agent Service / Azure OpenAI (agent patterns)
Google Cloud: Vertex AI Agent Builder / Vertex AI Extensions
OpenAI: Assistants API (platform-specific)

Open-source / self-managed alternatives

LangChain / LlamaIndex + a vector DB (OpenSearch, pgvector, Milvus, etc.)
Self-hosted model serving (requires GPUs, MLOps, security hardening)

Comparison table

Option	Best For	Strengths	Weaknesses	When to Choose
Oracle Cloud Generative AI Agents	OCI-native managed agents with governance	Managed pattern, IAM/compartments, integrates with OCI services	Feature set and connectors vary by region; less runtime control than DIY	You want managed agents in OCI with strong governance and simpler ops
OCI Generative AI (direct model API)	Custom agent frameworks	Maximum flexibility in orchestration	You build/operate orchestration, retrieval, evals	You need bespoke workflows or tool routing beyond managed agents
OCI Data Science	ML engineering lifecycle	Notebooks, pipelines, model ops	More work to build “agent product” experiences	You need custom ML + operations rather than managed assistants
AWS Bedrock Agents	AWS-native agent solutions	Tight AWS integration	Not OCI; different IAM/networking	Your platform is AWS-first
Azure AI agent offerings	Microsoft ecosystem	Integration with Microsoft stack	Not OCI; costs and governance differ	You’re standardized on Azure/Microsoft tooling
Google Vertex AI Agent Builder	Google-native agent solutions	Integration with GCP	Not OCI	GCP-first organizations
Self-managed (LangChain + vector DB)	Maximum control, portability	Full customization, vendor portability	Higher ops burden, security risks if done poorly	You need portability or features not offered by managed services

15. Real-World Example

Enterprise example: Global manufacturing internal SOP assistant

Problem
Thousands of pages of maintenance SOPs and safety procedures.
Engineers waste time searching and sometimes follow outdated steps.
Proposed architecture
Documents stored in OCI Object Storage with versioning.
A controlled ingestion process that updates the agent’s knowledge source.
API Gateway + an internal web portal for authenticated access.
Generative AI Agents configured to answer only from approved SOP docs.
OCI Logging/Audit enabled; dashboards for usage and error rate.
Why this service was chosen
OCI governance and compartment isolation fits enterprise controls.
Managed agent approach reduces custom platform work.
Expected outcomes
Reduced mean time to find procedures.
Fewer errors from outdated runbooks.
Better auditability of access and configuration changes.

Startup/small-team example: SaaS product documentation assistant

Problem
Small team gets repetitive technical questions about product setup.
Proposed architecture
Product docs and changelogs stored in Object Storage.
A small backend service on OCI Compute/Functions.
Backend calls Generative AI Agents for responses and applies rate limits.
Why this service was chosen
Faster implementation than building full RAG + orchestration from scratch.
Usage-based cost model fits variable demand.
Expected outcomes
Faster support responses and fewer interruptions to engineering.
Ability to scale support without hiring proportionally.

16. FAQ

1) Is “Generative AI Agents” a separate service from OCI Generative AI?
It can be presented either as a standalone service or as a capability within OCI’s broader Generative AI offerings. Verify the current product structure and console navigation in official docs for your region.

2) Do I need to train a model to use Generative AI Agents?
Typically, no. Agent solutions usually rely on existing foundation models and focus on configuration plus grounding with your knowledge. If you need custom training, look at OCI Data Science and related services.

3) How does grounding reduce hallucinations?
Grounding (RAG) provides relevant source text as context to the model. It reduces the need for the model to “guess,” but it does not guarantee perfect accuracy. You still need evaluation and guardrails.

4) Can I force the agent to answer only from my documents?
You can strongly instruct it to do so and configure knowledge grounding. Whether “strict” grounding enforcement is available depends on the service capabilities—verify in official docs—and you must test thoroughly.

5) Where should I store documents for an agent?
A common OCI-native approach is Object Storage for documents plus optional databases for metadata and entitlements. Choose based on data type, update frequency, and governance needs.

6) Can I use private networking (VCN-only) to access the service?
Some OCI services support private endpoints; many AI services use regional public endpoints. Verify whether Generative AI Agents supports private endpoints in your region, and design accordingly.

7) How do I authenticate from my application?
Prefer OCI workload identity (instance principals/resource principals) when running on OCI. Avoid embedding user API keys in code.

8) What are the main cost drivers?
Tokens (input/output), retrieval/embedding/indexing (if billed), Object Storage, and logging. High chat volume and long contexts increase costs quickly.

9) Should I log prompts and responses?
Only if required. Logs can contain sensitive data. Prefer logging metadata (request IDs, latency, error codes) and apply redaction if you must log content.

10) How do I prevent sensitive data from entering the model context?
Apply upstream controls: data classification, redaction, and entitlements. Never put secrets into knowledge documents. Consider adding DLP scanning in your ingestion pipeline.

11) Can I integrate this with ticketing systems or workflows?
Yes, typically via your application layer (Functions/OKE/Compute) and integrations (Oracle Integration Cloud or custom). The agent service itself may not directly connect to every tool—verify supported integrations.

12) How do I evaluate quality before production?
Create a test set of questions with expected answers, run regression tests on every knowledge update and instruction change, and measure accuracy, refusals, and unsafe outputs.

13) What happens if my document changes?
You generally need a re-ingestion/sync/index update so retrieval uses the latest content. Exact workflow depends on service features—verify in docs.

14) Is Generative AI Agents suitable for customer-facing chatbots?
It can be, but customer-facing use raises security, privacy, and brand risk. Use strict governance, safe defaults, human escalation, and consider human-in-the-loop for sensitive interactions.

15) What’s the best first project?
Start with an internal, low-risk assistant: HR policy Q&A, engineering docs helper, or IT runbook assistant. Keep documents small and curated, then expand.

17. Top Online Resources to Learn Generative AI Agents

Use Oracle’s official docs as your primary source of truth.

Resource Type	Name	Why It Is Useful
Official documentation	OCI Documentation (landing) – https://docs.oracle.com/en-us/iaas/	Starting point to navigate to Generative AI Agents docs, IAM, limits, APIs
Official documentation	OCI CLI install – https://docs.oracle.com/en-us/iaas/Content/API/SDKDocs/cliinstall.htm	Helps you automate uploads and deployments
Official pricing	Oracle Cloud Pricing – https://www.oracle.com/cloud/pricing/	Official pricing entry point
Official cost tool	OCI Cost Estimator – https://www.oracle.com/cloud/costestimator.html	Estimate usage-based costs without guessing
Free tier	Oracle Cloud Free Tier – https://www.oracle.com/cloud/free/	Check if any credits/free usage apply
Architecture references	Oracle Architecture Center – https://www.oracle.com/cloud/architecture-center/	Reference architectures for OCI patterns (API Gateway, Functions, security)
Observability docs	OCI Logging – https://docs.oracle.com/en-us/iaas/Content/Logging/home.htm	Configure logs and retention
Governance docs	OCI Audit – https://docs.oracle.com/en-us/iaas/Content/Audit/home.htm	Track administrative actions and changes
Security docs	OCI IAM – https://docs.oracle.com/en-us/iaas/Content/Identity/home.htm	Policies, compartments, groups, authentication patterns
Storage docs	OCI Object Storage – https://docs.oracle.com/en-us/iaas/Content/Object/home.htm	Document storage patterns and lifecycle management

Note: The exact Generative AI Agents documentation URL path can change; use the OCI documentation landing page search for “Generative AI Agents”.

18. Training and Certification Providers

The following training providers are listed as requested. Availability, course depth, and delivery modes can change—check each website for current offerings.

Institute	Suitable Audience	Likely Learning Focus	Mode	Website URL
DevOpsSchool.com	Engineers, DevOps, platform teams	DevOps/cloud fundamentals, CI/CD, operations patterns (check OCI-specific coverage)	Check website	https://www.devopsschool.com/
ScmGalaxy.com	Beginners to intermediate	DevOps tooling and SCM practices	Check website	https://www.scmgalaxy.com/
CLoudOpsNow.in	Cloud/ops practitioners	Cloud operations and operational readiness	Check website	https://cloudopsnow.in/
SreSchool.com	SREs, ops teams	Reliability engineering, SLOs, incident management	Check website	https://sreschool.com/
AiOpsSchool.com	Ops + AI practitioners	AIOps concepts, monitoring automation, AI in operations	Check website	https://aiopsschool.com/

19. Top Trainers

These sites are provided as training resources/platforms as requested. Verify course relevance to Oracle Cloud Generative AI Agents directly on each site.

Platform/Site	Likely Specialization	Suitable Audience	Website URL
RajeshKumar.xyz	DevOps/cloud training content	Beginners to experienced engineers	https://rajeshkumar.xyz/
devopstrainer.in	DevOps coaching/training	DevOps engineers, sysadmins	https://devopstrainer.in/
devopsfreelancer.com	Freelance/consulting-style enablement	Small teams needing hands-on help	https://devopsfreelancer.com/
devopssupport.in	Support/training services	Ops teams, production support engineers	https://devopssupport.in/

20. Top Consulting Companies

These companies are listed as requested. Validate capabilities, references, and OCI/AI expertise directly with each provider.

Company	Likely Service Area	Where They May Help	Consulting Use Case Examples	Website URL
cotocus.com	Cloud/DevOps/engineering services	Cloud adoption, platform engineering, automation	OCI landing zone, CI/CD pipelines, operational monitoring	https://cotocus.com/
DevOpsSchool.com	Training + consulting	Enablement, DevOps transformations	Building delivery pipelines, cloud governance practices	https://www.devopsschool.com/
DEVOPSCONSULTING.IN	DevOps consulting services	Assessments, implementation support	Production readiness, SRE practices, automation	https://devopsconsulting.in/

21. Career and Learning Roadmap

What to learn before this service

OCI fundamentals: compartments, VCN basics, IAM policies, tagging
Object Storage basics: buckets, encryption, lifecycle policies
API basics: REST, authentication, rate limiting
LLM fundamentals: tokens, context windows, temperature/top-p concepts (high-level)

What to learn after this service

Production RAG engineering: document preprocessing, chunking strategies, evaluation
Observability: dashboards, alerts, incident response for AI services
Security for AI: prompt injection threats, data leakage prevention, redaction
MLOps adjacent skills: model selection, A/B testing, drift-like monitoring for agent behavior

Job roles that use it

Cloud engineer / platform engineer (OCI)
Solutions architect
DevOps/SRE building internal tooling
AI/ML engineer (applied LLM + retrieval)
Security engineer (governance and controls for AI deployments)

Certification path (if available)

Oracle certifications change over time. Look for: – OCI Architect certifications (associate/professional) – OCI security and operations certifications – Any Oracle AI/ML learning paths that mention Generative AI

Verify current Oracle University offerings: – https://education.oracle.com/

Project ideas for practice

HR policy assistant with strict refusal behavior for unknown topics
IT runbook assistant with “ask clarifying questions first” prompt policy
Release notes summarizer + Q&A assistant for engineering
Compliance checklist assistant that outputs structured checklists (with citations if supported)
Multi-environment deployment: dev/test/prod compartments with budgets and alarms

22. Glossary

Agent: An application pattern where an LLM-driven system follows instructions and may retrieve knowledge and/or take actions to complete tasks.
Generative AI Agents: Oracle Cloud service for configuring and operating agent experiences (verify exact scope in your region).
LLM (Large Language Model): A model that generates and reasons over natural language.
Tokens: Units of text used for LLM input and output billing and limits.
RAG (Retrieval-Augmented Generation): Retrieving relevant documents and injecting them into the prompt context to ground responses.
Grounding: Constraining responses using retrieved authoritative content.
Compartment (OCI): A logical container for organizing resources and applying IAM policies.
IAM (Identity and Access Management): Policies and identities controlling access to OCI resources.
Instance principals / resource principals: OCI-native workload identities for authenticating without embedding keys.
OCI Object Storage: Durable storage for unstructured objects (documents, PDFs, text files).
OCI Audit: Service that records API calls and administrative events for governance.
OCI Logging: Centralized log ingestion, storage, and search capabilities.
API Gateway: Managed gateway for APIs that adds auth, rate limiting, routing, and logging.

23. Summary

Generative AI Agents (Oracle Cloud) is a managed service in the Analytics and AI category designed to help teams build and operate agent-style generative AI assistants with enterprise governance. It fits best when you want OCI-native controls (IAM, compartments, audit/logging) and you need assistants grounded in your organization’s documents.

Key takeaways: – Architect for grounding (RAG), strict instructions, and robust evaluation to reduce hallucinations. – Costs are primarily usage-based (often token-driven) plus storage, retrieval/indexing (if applicable), and operational services—use Oracle’s official pricing pages and cost estimator rather than guessing. – Secure production deployments typically put API Gateway + a backend in front of the service, use workload identity, and minimize sensitive logging. – Start small with a focused internal assistant, then scale with environment separation, monitoring, and governance.

Next learning step: use the OCI docs landing page to find the latest Generative AI Agents documentation for your region, then expand this lab into a production pattern with API Gateway, budgets/alerts, and a controlled document ingestion pipeline.

rajeshkumar

Category