The Complete OAC AI Functions Setup Guide

AI Built Into the Data Layer — Unlock Insights from Unstructured Text

Every enterprise sits on a goldmine of unstructured text — customer feedback, support tickets, survey responses, CRM notes, compliance reports — yet most analytics platforms treat these columns as opaque strings, invisible to dashboards and KPIs. Oracle Analytics Cloud changes that with three AI functions built directly into the data layer: AI_GENERATE(), AI_AGG(), and AI_FILTER().

These aren't bolt-on chatbots or separate AI tools that require data exports. They live inside OAC's Workbook expression editor — right alongside SUM(), RANK(), and FORECAST(). Write a plain English prompt as a quoted string argument, point it at any text column, and the LLM classifies, summarizes, or filters your data in real time. No Python, no ML pipeline, no data movement. The result is a new column in your workbook — structured, queryable, ready for dashboards.

In this guide, I'll walk you through everything you need to get this working: from registering an AI model in OAC, setting up Select AI in Autonomous Database, all the way to running AI_GENERATE(), AI_AGG(), and AI_FILTER() against real customer data from Oracle's SH schema — which already exists in my Autonomous Database and required no additional setup. Every code snippet is copy-paste ready and has been validated live in OAC's expression editor (March 2026 release) against the SH sample schema that ships pre-loaded with Autonomous Database — including the gotchas where the current documentation is inconsistent with what actually works. I've also included the troubleshooting section I wish I'd had the first time I set this up.

Prerequisites & Architecture Overview

Before diving into code, it helps to understand how all the pieces connect. OAC's Generative AI functions don't call LLMs directly from the analytics layer — they route calls through a registered model connection. When you write AI_GENERATE(COMMENTS, 'your prompt', OPENAI), the name OPENAI is just the label you gave that registered connection. The function itself doesn't know or care which provider is behind it — that's determined entirely by how the connection was set up.

There are two ways to register a model connection in OAC:

• OCI Generative AI Service — registered directly in OAC via OAC Console → Machine Learning → AI Services / AI Connections. Uses Oracle's hosted models (Llama 3, Cohere Command, etc.) with no external network calls. Best if you're already running OAC on OCI and want to stay within Oracle's infrastructure.
• Autonomous Database / Autonomous AI Lakehouse via Select AI — you configure an AI profile in Autonomous Database using DBMS_CLOUD_AI.CREATE_PROFILE(), then expose that database as a data source in OAC. The OAC model name is defined when you create the connection — it references the profile name used in the database-side calls. This path supports providers such as OpenAI, Anthropic, Google, Cohere, Azure OpenAI, and others — any LLM that ADW's DBMS_CLOUD_AI layer supports (availability varies by region).
  📌 Naming note

  Autonomous AI Lakehouse is the next-generation evolution and strategic rebranding of Autonomous Data Warehouse (ADW) — not a separate product. From an OCI provisioning perspective, what was previously the ADW workload type is now offered as the Autonomous AI Lakehouse workload, built on the same Autonomous Database platform. If you already know ADW, think of Autonomous AI Lakehouse as ADW plus expanded lakehouse and AI capabilities, with Oracle's strategic positioning shifted toward "AI data platform" rather than pure data warehousing. The DBMS_CLOUD_AI setup steps are identical regardless of which workload type you provisioned.

Both paths produce the same result from OAC's perspective: a registered model you can reference in expression editors across Workbooks, Datasets, Data Flows, and Semantic Models.

Step 0 — Register a Generative AI Model in OAC

This is the gate that everything else depends on. As of the March 2026 release, none of the AI functions (AI_GENERATE, AI_AGG, AI_FILTER) will appear in your expression editor until at least one model is registered. Here's how.

Navigate to your OAC Homepage → Generative AI Models (top navigation or hamburger menu depending on your version). Click Register Model. You'll be prompted to choose between two sources:

Path A — OCI Resource Connection (Recommended for OCI-native deployments)

This path stays entirely within the OCI network — no external API calls, no network ACL configuration required. It's the simplest option if you're running OAC on OCI.

allow group <your-group-name> to use generative-ai-family in compartment <your-compartment-name>

1. In the Register Model dialog, select OCI Resource Connection
2. Choose the OCI Connection configured for your tenancy
3. Select the Compartment where your Generative AI Service is enabled
4. Pick a model from the available endpoints (e.g., meta.llama-3-70b-instruct, cohere.command-r-plus)
5. Give the registered model a display name and click Save

Path B — Autonomous AI Lakehouse (Select AI)

If you want to use OpenAI's GPT-4o, Anthropic's Claude, or another provider — or if your organization already has an Autonomous Database with Select AI configured — this path gives you the most provider flexibility. OAC delegates all LLM calls through the ADW DBMS_CLOUD_AI layer.

1. In the Register Model dialog, select Autonomous AI Lakehouse
2. Choose the Connection pointing to your ADW instance
3. Select the AI Profile already configured in that ADW — this is the profile name from DBMS_CLOUD_AI.CREATE_PROFILE(), which you'll set up in the next section
4. Give the registered model a display name and click Save

Step 1 — Configure Select AI in Autonomous Database

Skip this section if you're using Path A (OCI Resource Connection) exclusively. If you're routing through Autonomous Database, here's the complete setup — run as ADMIN unless noted.

Step 1: Create the Database User

-- Create a dedicated user
CREATE USER ADB_USER IDENTIFIED BY "<YourStrongPassword>";
GRANT DWROLE TO ADB_USER;
GRANT CONNECT TO ADB_USER;

-- If querying SH schema tables, grant SELECT from the table owner
ALTER USER SH IDENTIFIED BY "<strong_password>";

-- Connect as SH, then grant:
GRANT SELECT ON SH.CUSTOMERS TO ADB_USER;
GRANT SELECT ON SH.SUPPLEMENTARY_DEMOGRAPHICS TO ADB_USER;
GRANT SELECT ON SH.SALES TO ADB_USER;
GRANT SELECT ON SH.PRODUCTS TO ADB_USER;
GRANT SELECT ON SH.PROMOTIONS TO ADB_USER;

Step 2: Grant EXECUTE on DBMS_CLOUD_AI

GRANT EXECUTE ON DBMS_CLOUD_AI TO ADB_USER;

-- Also grant DBMS_CLOUD if not already done via DWROLE
GRANT EXECUTE ON DBMS_CLOUD TO ADB_USER;

Step 3: Grant Network ACL Access

BEGIN
  DBMS_NETWORK_ACL_ADMIN.APPEND_HOST_ACE(
    host => 'api.openai.com',          -- change per provider
    ace  => xs$ace_type(
      privilege_list => xs$name_list('http'),
      principal_name => 'ADB_USER',
      principal_type => xs_acl.ptype_db
    )
  );
END;
/

Use the correct host for your provider. See the provider reference table below for a complete list.

Step 4: Create the Credential

BEGIN
  DBMS_CLOUD.CREATE_CREDENTIAL(
    credential_name => 'OPENAI_CRED',
    username        => OPENAI,          -- user-defined label, not an account
    password        => 'sk-...'            -- your actual API key
  );
END;
/

Step 5: Create the AI Profile

The AI profile is the configuration object that ties everything together: which provider to call, which credential to authenticate with, which model to use, and — critically — which tables the LLM should reference when translating natural language into SQL.

BEGIN
  DBMS_CLOUD_AI.CREATE_PROFILE(
    profile_name => OPENAI,
    attributes   => '{
      "provider":        "openai",
      "credential_name": "OPENAI_CRED",
      "model":           "gpt-4o",
      "object_list": [
        {"owner": "SH", "name": "customers"},
        {"owner": "SH", "name": "supplementary_demographics"},
        {"owner": "SH", "name": "sales"},
        {"owner": "SH", "name": "products"},
        {"owner": "SH", "name": "promotions"},
        {"owner": "SH", "name": "countries"}
      ]
    }'
  );
END;
/

The 5 Select AI Actions

Once the profile is set up, you can call it with five different actions:

Step 6: Test Your Setup

-- 1. See the generated SQL before running it
SELECT DBMS_CLOUD_AI.GENERATE(
  prompt       => 'how many customers exist',
  profile_name => OPENAI,
  action       => 'showsql'
) FROM DUAL;

-- Expected: SELECT COUNT("CUST_ID") AS "Total_Customers" FROM "SH"."CUSTOMERS"

-- 2. Run and get a narrative answer
SELECT DBMS_CLOUD_AI.GENERATE(
  prompt       => 'what are the top 3 customers in San Francisco',
  profile_name => OPENAI,
  action       => 'narrate'
) FROM DUAL;

-- 3. Shorthand syntax (SQL*Plus / SQLcl only, NOT in Database Actions Worksheet)
EXEC DBMS_CLOUD_AI.SET_PROFILE(OPENAI);
SELECT AI narrate what are the top 3 customers in San Francisco;

Supported AI Providers

The full per-provider setup instructions (API key locations, credential formats, and ACL hosts) are documented in the official Manage AI Profiles page. The ACL host values for each provider are: api.openai.com (OpenAI), api.cohere.ai (Cohere), api.anthropic.com (Anthropic), generativelanguage.googleapis.com (Google), api-inference.huggingface.co (Hugging Face), bedrock-runtime.us-east-1.amazonaws.com (AWS Bedrock). OCI Generative AI requires no ACL.

The setup pattern is conceptually identical for all providers — create a credential, grant network ACL access (if needed), create the profile with the provider name. Only the host, credential format, and provider string change. Supported providers include the following; exact availability may vary by region.

The Three LLM AI Functions at a Glance

With a model registered, three new functions become available in OAC's expression editors. They look like any other analytics function — but instead of computing a number, they call an LLM. Here's how they differ:

AI_GENERATE() — Row-Level Text Enrichment

How It Works

AI_GENERATE() processes your dataset one row at a time. For each row, it constructs a prompt by concatenating your template string with values from that row's columns, sends that prompt to the registered LLM, and stores the response as a new column value. The next row gets its own independent LLM call — there is no cross-row context.

Think of it as a CASE WHEN that uses natural language instead of boolean conditions — and an AI instead of hard-coded rules.

Syntax

AI_GENERATE(
  input_column,            -- bare column name (no quotes, no table qualifier)
  'prompt_string',         -- instructions to the LLM
  model_name               -- registered model name (no quotes)
)

-- ✓ Confirmed working — classify customer comments with a sentiment label:
-- Name field (top of dialog): Sentiment
CASE WHEN COMMENTS IS NULL OR LENGTH(TRIM(COMMENTS)) = 0
THEN 'No Comment'
ELSE AI_GENERATE(
  COMMENTS,
  'Classify this feedback as Positive, Negative, Mixed, or Neutral. Return only the label.',
  OPENAI
)
END

-- ⚠ Common mistakes that throw nQSError: 26012:
--   ✗ AI_GENERATE("COMMENTS", ...) — quoted column name (treated as literal string)
--   ✗ AI_GENERATE("TABLE"."COMMENTS", ...) — table-qualified column name
--   ✗ AI_GENERATE(COMMENTS, ..., OPENAI) AS SENTIMENT — AS alias in expression body
--   ✗ AI_GENERATE(COMMENTS, ..., 'OPENAI') — quoted model name
--   Use the Name field at the top of the dialog for your column label.

📸 OAC Expression Editor — AI_GENERATE() · Sentiment · ✅ Calculation validated

Full Example — Logical SQL

-- ✓ Basic: bare column names, model name unquoted, no alias
AI_GENERATE(
  COMMENTS,
  'Classify this customer feedback as Positive, Negative,
Mixed, or Neutral. Return only the label.',
  OPENAI                              -- unquoted model name
)

-- ✓ Recommended: wrap with NULL guard — prevents hallucination on empty rows
CASE WHEN COMMENTS IS NULL OR TRIM(COMMENTS) = ''
THEN 'No Comment'
ELSE
  AI_GENERATE(
    COMMENTS,
    'Classify this customer feedback as Positive, Negative,
Mixed, or Neutral. Return only the label.',
    OPENAI
  )
END

-- ⚠ Do NOT include AS SENTIMENT — the Name field is your column label.

Real Data Example

The following shows AI_GENERATE() applied to real customer comments from the SH schema's SUPPLEMENTARY_DEMOGRAPHICS table. Each row receives its own independent LLM call — both the SENTIMENT and TOPIC_TAG columns are AI-generated outputs.

↑ Blue-italic columns are AI_GENERATE() outputs — one LLM call per row, zero hand-coded rules

Best Prompt Practices for AI_GENERATE()

• Be explicit about format. "Return only the label" or "Respond in JSON" dramatically reduces hallucination and parsing headaches.
• Include few-shot examples. If you need consistent output, add 2–3 examples directly in your prompt template before the actual row data.
• Keep prompts focused. Each AI_GENERATE() call gets its own LLM call — if you need two outputs (sentiment + topic), either make two AI_GENERATE() columns or have the LLM return both in a delimited string you parse later.
• Watch token costs. If your COMMENTS column contains very long text, consider truncating with SUBSTR() before passing to AI_GENERATE().

AI_AGG() — Group-Level Summarization

How It Works

AI_AGG() is fundamentally different from AI_GENERATE() in one key way: instead of running a separate LLM call for each row, it collects all text values within a group and sends them together in a single prompt. The result is one synthesized response per group — not per row.

Think of it as GROUP BY for language. Just as SUM(revenue) rolls up individual sales figures into a total per category, AI_AGG() rolls up individual customer comments into a theme summary per segment.

Syntax

AI_AGG(
  input_column,             -- the text column to aggregate across the group
  'task_description',       -- instructions for what to do with the grouped text
  model_string               -- registered model name (no quotes needed)
  [, 'optional_param_json'] -- optional: {"mode":"EXTERNAL","parameter":{"temperature":0.7,"max_token":205}}
)

-- Note: AI_AGG requires a group attribute to be present in your visualization
-- or query context (e.g., drop OCCUPATION into your table alongside this measure)

Full Example — Logical SQL

-- ✓ Workbook / Dataset expression editor — bare column names, no alias
AI_AGG(
  COMMENTS,
  'Summarize the key themes and overall sentiment from these
customer comments. Identify the top 2 recurring issues.
Keep your response to 2–3 sentences.',
  OPENAI
)

-- ⚠ Critical: Only put OCCUPATION + this calc in your table visualization.
--   Do NOT add COMMENTS to the same table — it breaks grouping.
--   Each unique COMMENTS value becomes its own group → row-level output.
--   No AS alias — Name field at top of dialog is your column label.

📸 OAC Expression Editor — AI_AGG() · Occupation Insights · ✅ Calculation validated

Real Data Example

Using the same SUPPLEMENTARY_DEMOGRAPHICS.COMMENTS data — but now instead of classifying each row individually, we're synthesizing entire segments into one summary per group. Each row in the result below represents many input rows collapsed into a single LLM call.

↑ All 11 OCCUPATION groups — actual output from OAC AI_AGG() against SH schema SUPPLEMENTARY_DEMOGRAPHICS. One LLM call per group.

When to Choose AI_AGG() Over AI_GENERATE()

• Use AI_AGG() when you want a single synthesized insight for a group — customer segment summaries, regional feedback themes, product category sentiment
• Use AI_GENERATE() when you need individual output for each record — classifying each ticket, tagging each review, translating each description
• Combine them when you want both: first use AI_GENERATE() to label each row, then use AI_AGG() to summarize labeled groups

AI_FILTER() — Natural Language Boolean Filtering

How It Works

AI_FILTER() evaluates a yes/no question for every row and returns TRUE or FALSE. You can then use this boolean to filter a workbook visualization, drive a conditional formatting rule, power an alert, or route records to a downstream process — all without writing a single regex, keyword list, or custom ML model.

The power of AI_FILTER() is that it understands intent, not just keywords. A customer saying "I'm ready to move on" and another saying "I won't be coming back" would both return TRUE for the question "Is this customer at risk of churning?" — even though they use completely different words.

Syntax

AI_FILTER(
  'predicate_prompt',  -- ⚠ predicate comes FIRST: the natural-language condition to test
  input_string,        -- the column value to classify (per row)
  model_string          -- registered model name (no quotes needed)
  [, 'optional_param_json'] -- optional: {"mode":"EXTERNAL","parameter":{"temperature":0.7,"max_token":205}}
)

-- Returns TRUE when the model answers yes to the predicate question
-- Returns FALSE for anything else (no, uncertain, null)
-- Wrap in CASE WHEN to map TRUE/FALSE to human-readable labels:
-- ✓ Confirmed working: AI_FILTER returns a native boolean — no = 'TRUE' comparison needed
CASE WHEN AI_FILTER('Is this review positive?', text_column, OPENAI)
  THEN 'Positive'
  ELSE 'Needs Review'
END

Full Example — Logical SQL

-- ✓ Calc 1: Churn Risk Flag — confirmed working syntax (live-tested)
-- NULL guard: LENGTH(TRIM()) = 0 catches true NULLs AND whitespace-only strings (' ')
-- TRIM(COMMENTS) = '' also passes validation but misses single-space values → use LENGTH form
CASE WHEN COMMENTS IS NULL OR LENGTH(TRIM(COMMENTS)) = 0
THEN 'No Comment'
WHEN AI_FILTER(
  'Does this comment suggest the customer may stop purchasing or is at risk of leaving?',
  COMMENTS,
  OPENAI
)
THEN 'At Risk'
ELSE 'Retained'
END

-- ✓ Calc 2: Price Complaint — separate calculated column
CASE WHEN COMMENTS IS NULL OR LENGTH(TRIM(COMMENTS)) = 0
THEN 'No Comment'
WHEN AI_FILTER(
  'Is the customer specifically complaining about price or cost being too high?',
  COMMENTS,
  OPENAI
)
THEN 'Price Complaint'
ELSE 'OK'
END

-- ✓ Calc 3: Privacy Concern — separate calculated column
CASE WHEN COMMENTS IS NULL OR LENGTH(TRIM(COMMENTS)) = 0
THEN 'No Comment'
WHEN AI_FILTER(
  'Is the customer expressing concern about privacy or not wanting to share personal information?',
  COMMENTS,
  OPENAI
)
THEN 'Privacy Concern'
ELSE 'OK'
END

-- ⚠ Key rules confirmed from live testing:
--   • AI_FILTER returns a native boolean — use WHEN AI_FILTER(...) THEN, NOT = 'TRUE'
--   • Model name is unquoted: OPENAI, not 'OPENAI'
--   • No AS alias in expression body — use the Name field at top of the dialog
--   • NULL guard (LENGTH(TRIM()) = 0) prevents hallucination on empty rows

📸 OAC Expression Editor — AI_FILTER() · Churn Risk · ✅ Calculation validated

Real Data Results — Confirmed Live Output

↑ Real output from OAC AI_FILTER() against SH schema SUPPLEMENTARY_DEMOGRAPHICS. Note: the model correctly identifies "remove my name from your list" and "have stopped now" as At Risk, while nuanced dissatisfaction without explicit departure intent returns Retained.

Churn Prediction Without ML — Using AI Functions as a Lightweight Alternative

Traditional churn prediction requires significant investment: labelled training data, feature engineering, model selection, hyperparameter tuning, and ongoing retraining as customer behaviour shifts. OAC's AI Functions offer a pragmatic alternative that delivers useful churn signals in minutes, directly inside your existing analytics workbook — as long as your dataset includes a text column such as customer comments, support notes, or feedback responses.

AI_FILTER() as a Churn Classifier

The Churn Risk column we built earlier is a working churn classifier. The predicate "Does this comment suggest the customer may stop purchasing or is at risk of leaving?" is semantically equivalent to the binary target variable a supervised ML model would learn to predict. The difference: the LLM has already learned that language from billions of examples — you just have to ask.

-- Churn prediction in a single calculated column
-- Equivalent to a binary ML classifier, but with zero training data
CASE WHEN COMMENTS IS NULL OR LENGTH(TRIM(COMMENTS)) = 0
THEN 'No Signal'
WHEN AI_FILTER(
  'Does this comment suggest the customer may stop purchasing or is at risk of leaving?',
  COMMENTS,
  OPENAI
)
THEN 'At Risk'
ELSE 'Retained'
END

AI_AGG() for Segment-Level Churn Intelligence

Where AI_FILTER() flags individual at-risk customers, AI_AGG() answers the follow-up question: why are customers in a particular segment at risk? Group by occupation, region, product category, or any dimension, and you get a natural-language churn narrative per segment — the kind of insight that would normally require a data scientist to manually analyse cluster outputs.

-- Why are customers in each occupation group at risk?
-- Add OCCUPATION to the table viz, AI_AGG gives one summary per group
AI_AGG(
  COMMENTS,
  'Summarize the main reasons these customers appear to be at risk of churning. Be specific about themes like pricing, service, privacy, or product gaps.',
  OPENAI
)

How This Compares to Traditional ML Churn Models

A Three-Function Churn Dashboard

Combine all three functions in a single OAC workbook to build a complete churn intelligence view with no ML infrastructure:

Availability Matrix — Where Can You Use Each Function?

Not all three functions are available everywhere. Here's the complete picture:

'{ "mode": "EXTERNAL", "parameter": { "temperature": 0.7, "max_token": 205 } }'

Why is AI_AGG() excluded from Semantic Models and Data Flows? Because AI_AGG() requires a group attribute in every call — it must know how to partition rows into groups before aggregating. Semantic Models and Data Flows don't support on-the-fly group specification the way Datasets and Workbooks do. This mirrors the same constraint as other aggregation functions that require an explicit GROUP BY context.

Troubleshooting — Common Errors and Fixes

Things don't always work on the first try. Here are the errors I've hit most often and exactly how to fix them.

AI_GENERATE(COMMENTS, 'Classify as Positive, Negative, Mixed or Neutral.', OPENAI) AS SENTIMENT

AI_GENERATE(COMMENTS, 'Classify as Positive, Negative, Mixed or Neutral.', OPENAI)

CASE WHEN AI_FILTER('Is this at risk?', COMMENTS, OPENAI) = 'TRUE'
THEN 'At Risk'  -- ✗ nQSError: 26012 Near <=>
ELSE 'Retained'
END

CASE WHEN AI_FILTER('Is this at risk?', COMMENTS, OPENAI)
THEN 'At Risk'  -- ✓ Correct — AI_FILTER() is the condition itself
ELSE 'Retained'
END

CASE WHEN COMMENTS IS NULL OR TRIM(COMMENTS) = ''
THEN 'No Comment'
ELSE AI_GENERATE(
  COMMENTS,
  'Classify this feedback as Positive, Negative, Mixed, or Neutral. Return only the label.',
  OPENAI
)
END

BEGIN DBMS_CLOUD.DROP_CREDENTIAL('OPENAI_CRED'); END;
/
BEGIN
  DBMS_CLOUD.CREATE_CREDENTIAL(
    credential_name => 'OPENAI_CRED',
    username        => OPENAI,
    password        => 'sk-your-new-key'
  );
END;
/

-- Verify which user you're connected as
SELECT USER FROM DUAL;

-- Create the credential under this user
BEGIN
  DBMS_CLOUD.CREATE_CREDENTIAL(
    credential_name => 'OPENAI_CRED',
    username        => OPENAI,
    password        => 'sk-...'
  );
END;
/

-- ❌ Doesn't work in Database Actions Worksheet:
SELECT AI how many customers exist;

-- ✓ Use this instead:
SELECT DBMS_CLOUD_AI.GENERATE(
  prompt       => 'how many customers exist',
  profile_name => OPENAI,
  action       => 'runsql'
) FROM DUAL;

GRANT EXECUTE ON DBMS_CLOUD_AI TO ADB_USER;
GRANT EXECUTE ON DBMS_CLOUD     TO ADB_USER;

-- For granting SH table access when ADMIN doesn't have GRANT OPTION:
ALTER USER SH IDENTIFIED BY "<password>";
-- Then connect as SH:
GRANT SELECT ON SH.CUSTOMERS TO ADB_USER;

-- Last resort for demos only — DO NOT use in production:
GRANT PDB_DBA TO ADB_USER;

SELECT host, acl
FROM DBA_NETWORK_ACLS
WHERE host = 'api.openai.com';

-- If nothing returned, re-run the APPEND_HOST_ACE step from §04

EXEC DBMS_CLOUD_AI.DROP_PROFILE(OPENAI);

BEGIN
  DBMS_CLOUD_AI.CREATE_PROFILE(
    profile_name => OPENAI,
    attributes   => '{
      "provider":        "openai",
      "credential_name": "OPENAI_CRED",
      "model":           "gpt-4o",
      "object_list": [{"owner": "SH", "name": "customers"}]
    }'
  );
END;
/

Quick Verification Checklist

Run these queries to confirm everything is in place before testing AI functions:

-- 1. Check your execute privileges
SELECT table_name AS package_name, privilege
FROM USER_TAB_PRIVS
WHERE table_name IN ('DBMS_CLOUD_AI', 'DBMS_CLOUD');

-- 2. Check credentials
SELECT credential_name, username, enabled
FROM USER_CREDENTIALS
WHERE credential_name = 'OPENAI_CRED';

-- 3. Check AI profiles
SELECT profile_name, status
FROM USER_CLOUD_AI_PROFILES;

-- 4. Verify active session profile
SELECT DBMS_CLOUD_AI.GET_PROFILE() FROM DUAL;

Clean Slate — Remove Everything and Start Over

-- 1. Clear profile from current session
BEGIN DBMS_CLOUD_AI.CLEAR_PROFILE; END;
/

-- 2. Drop the AI profile
EXEC DBMS_CLOUD_AI.DROP_PROFILE(OPENAI);

-- 3. Drop the credential
BEGIN DBMS_CLOUD.DROP_CREDENTIAL('OPENAI_CRED'); END;
/

-- 4. (Optional) Drop the user entirely — run as ADMIN
-- WARNING: CASCADE permanently deletes all user objects
DROP USER ADB_USER CASCADE;

The opinions and views shared in this blog are solely my own and do not represent the official stance or policy of Oracle Corporation or any organization I am associated with. This content reflects my personal insights based on hands-on experience and should be interpreted as such.