How I Built an Oracle AI-Driven Support Tool for Oracle Cloud Using Databricks, OCI and Claude

If you've spent any time supporting Oracle Cloud ERP, HCM, or EPM, you already know the pattern. A user submits a ticket about a payroll element not processing. You ask a series of diagnostic questions. You identify whether it's an effective date problem, a payroll cutoff issue, a security profile gap, or one of a dozen other root causes. You document the fix. Two months later, a different user hits the same issue and the whole cycle starts over.

This post walks through a tool I built to break that cycle. It is called Solution Designer, and it uses an agentic AI approach on top of Databricks to give your Oracle support team structured, consistent, context-aware troubleshooting guidance -- without requiring users to know exactly what to ask.

The Problem With Generic AI for Oracle Support

The first instinct most teams have is to point users at a general-purpose chatbot. "Just ask it your Oracle question." The problem is that Oracle Cloud is enormous and deeply configuration-dependent. A question like "why isn't my payroll processing?" has radically different answers depending on element type, entry method, effective date, pay period status, and whether payroll has already been run for the period.

A generic chat interface puts all of that burden on the user. They have to know which details matter, phrase the question precisely, and interpret an answer that wasn't tuned to their specific setup.

I took a different approach. Instead of a free-form chat interface, I built a guided intake flow that collects the right diagnostic signals before the AI ever generates a response. The model then has full context to produce a solution that actually fits the situation.

What Solution Designer Does

At its core, the tool is a Flask application deployed as a Databricks App. It connects to OCI or Claude via the Databricks Foundation Model API or the OCI LLM API. The experience works like this:

1. The user picks a scenario from a categorized library. The library currently covers 31 Oracle scenarios across ERP (Payables, Procurement, Receivables, General Ledger, Fixed Assets, Inventory, Projects), HCM (Payroll, Absence, HCM Data Loader, Fast Formula, Security, Workforce Compensation), EPM (Consolidation, Planning Data Loads, Rule Troubleshooting), and integrations (REST API, FBDI, BI Publisher, OTBI, Workflow Notifications).

2. The tool presents a structured intake form specific to that scenario. For Payroll Element Entries, for example, the user answers eight targeted questions: what type of element, how it was created, the specific symptom, how many employees are affected, the effective date, the pay period, whether payroll has already run, and the current status of the element entry. Every question has help text explaining why it matters.

3. The scenario definition includes edge cases. Each scenario JSON file encodes known Oracle gotchas as conditional logic. If the effective date falls outside the pay period, the system flags that as a high-severity edge case and incorporates it into the prompt context automatically. If payroll already ran and the entry is still unprocessed, the tool knows to surface the rollback-or-next-period decision. Users do not have to discover these traps manually.

4. OCI or Claude generates a tailored solution. With the structured inputs and edge case context loaded, OCI/Claude produces a step-by-step resolution path that is specific to what the user actually described. This is not a generic knowledge article. It is a direct answer to their exact configuration.

5. The user can refine through follow-up questions. After the initial solution, the conversation stays open. Users can ask clarifying questions and the system maintains full session context so responses stay coherent. Sessions persist in a Unity Catalog Delta table so the conversation survives page refreshes and can be resumed later.

6. After rating the solution, the user can generate a training document. Once the problem is solved and the user rates the response, a "Generate Training Doc" button appears. They specify a format (Markdown, slide outline, or quick-start guide) and a target audience, and OCI/Claude turns the solution into a shareable knowledge artifact. This is where individual troubleshooting events compound into reusable organizational knowledge.

How the Knowledge Base Works

Each scenario is a JSON file that defines intake questions, answer options, help text, edge cases, and the conditions that trigger them. Here is a simplified example from the Payroll Element Entries scenario:

```json

{

  "id": "oracle-hcm-payroll-element-entries",

  "category": "Oracle HCM",

  "title": "Payroll Element Entries Not Processing",

  "intake_questions": [

    {

      "id": "effective_date",

      "question": "What is the effective date of the entry?",

      "type": "text",

      "required": true,

      "help_text": "Enter date in format MM/DD/YYYY - must be within pay period"

    }

  ],

  "edge_cases": [

    {

      "condition": "effective_date outside of pay_period",

      "impact": "Entry will not process in expected period. Must match effective date to pay period or entry will be skipped.",

      "severity": "high"

    }

  ]

}

```

This structure means the expertise lives in the JSON, not in the prompt. Adding a new scenario or a new edge case is a file edit, not a code change. The knowledge base hot-reloads, so updates go live without a restart.

The Architecture on Databricks

Running this on Databricks was a deliberate choice. The team already uses the platform, so authentication, security, and data governance come for free. Here is the technical stack:

- Databricks Apps for hosting the Flask application

- Databricks Foundation Model API to call Claude (Sonnet 4.5 at time of writing) without managing any external API credentials or you can use the OCI LLM API and connect to it using Python from within the solution

- Unity Catalog Delta tables for two purposes: structured logging of every interaction to `ef_dv.raw_dev_metadata.solution_designer_logs`, and session persistence in `ef_dv.raw_dev_metadata.conversation_sessions`

- Serverless SQL Warehouse for querying those Delta tables from the app

- On-behalf-of (OBO) authentication so every request to Databricks runs under the identity of the actual user, not a shared service account

The logging design deserves a mention. Every time a user generates a solution, submits feedback, or asks a follow-up question, a structured record lands in the Delta table with fields for user identity, scenario ID, scenario category, satisfaction rating, time saved, duration, and the interaction text. That gives leadership a real ROI dashboard backed by queryable data rather than estimates.

How We Built This With Agentic Development

The development process itself is worth describing because it reflects a pattern that works well for Oracle-specific tooling.

We used GitHub Copilot in agent mode throughout the build. The agent did not just autocomplete code; it was given feature requirements and asked to reason through the implementation, identify edge cases in its own output, and iterate. The key discipline was keeping the agent's scope narrow. Each session had one focused objective: add session persistence, add the feedback loop, fix a specific datetime bug in Delta table reads, resolve an issue with the resume-session banner showing stale state.

This approach works well for Oracle support tooling for a specific reason: Oracle Cloud problems are well-bounded. The diagnostic questions for a 3-way match hold resolution are not the same as the diagnostic questions for an HCM Fast Formula error. That domain specificity is an asset when working with an AI coding agent because you can describe the scenario structure precisely and the agent can reason about it correctly.

The iterative cycle looked like this:

1. Identify a gap in the user experience (example: returning to a previously solved scenario still presented the rating form instead of the completed state).

2. Trace the root cause through the code. In this case, the `/feedback` endpoint stored the rating on the session's last interaction in the Delta table but intentionally left session status as `active`. The frontend never checked whether the last interaction already had feedback attached.

3. Write a targeted fix. The solution was a new `restoreFeedbackStateFromHistory()` function in the frontend that reads the persisted rating, locks the feedback buttons, skips the rating form, and surfaces the "Generate Training Doc" button directly. No backend changes needed.

4. Run the 329-test suite to verify no regressions.

5. Deploy with the PowerShell script that syncs files to the Databricks workspace and triggers a new app deployment.

6. Confirm SUCCEEDED in the Databricks Apps deployment status.

The agent accelerated every step but did not replace the domain judgment calls. Decisions like "should the session status flip to solved when feedback is submitted, or should we leave it active so users can keep the conversation going?" require understanding the Oracle support workflow. The agent implements whatever direction you give it; you still have to give the right direction.

What This Looks Like in Practice

Consider a real scenario: an Oracle Finance team is getting 3-way match holds on vendor invoices. Previously, a ticket would come in, a knowledgeable team member would spend 15 to 45 minutes asking diagnostic questions via email or a Teams chat, and then write up a resolution.

With Solution Designer, the user navigates to the "3-Way Match Hold Resolution in Payables" scenario. They answer questions about hold type (quantity vs. price variance), tolerance settings, receipt status, PO type, and approval status. The tool detects relevant edge cases -- for example, if it is a price variance hold on a blanket PO, there is a specific Oracle behavior around line-level vs. header-level tolerances that trips people up repeatedly. The solution it generates addresses exactly that combination. If the user is satisfied, they rate the response, click "Generate Training Doc," specify their audience as "Oracle Finance users," and download a formatted guide they can drop into their SharePoint or Confluence space.

The time saved compounds across every person who hits that scenario going forward.

Click on the Images to Expand Them~

What We Learned

A few things stand out after building this:

Structure beats prompting. The quality improvement from giving AI structured inputs with pre-evaluated edge cases is larger than any prompt engineering trick. When the model knows that the effective date is outside the pay period because the scenario definition explicitly flagged it, the response is categorically more useful than when the user tries to describe that situation in free text.

Persistence changes the support dynamic. When solutions survive as resumable sessions in Delta, the tool stops being a one-shot query tool and starts being a case management layer. Users come back to the same session when a problem resurfaces, add follow-up context, and build a richer record of what was tried and what worked.

Feedback closes the loop. The satisfaction ratings and time-saved estimates that land in the Delta log are not vanity metrics. They identify which scenarios are working and which ones need better edge case coverage. The scenarios with low success rates are the ones that need a knowledge base update. That is a tractable engineering task.

Domain expertise encodes well into JSON. Oracle Cloud has well-documented configuration patterns and well-known failure modes. That knowledge, once captured in the scenario JSON format, is reusable forever. An experienced Oracle consultant or admin can encode years of diagnostic heuristics in an afternoon and make them available to everyone on the team immediately.

Getting Started If You Want to Build Something Similar

The approach is not specific to this stack. The core pattern is: structured intake + knowledge-encoded edge cases + LLM synthesis + persistent sessions. You need:

- A way to call a capable LLM (Databricks Foundation Model API, OCI LLM, Azure OpenAI, or similar)

- A JSON or database structure to encode your domain knowledge

- A lightweight web framework (Flask works well; FastAPI is another good option)

- A persistence layer for sessions and logs (Delta on Databricks is convenient if you are already there; a Postgres database works just as well and of course OCI Autonomous Databases!)

If your organization runs Oracle Cloud and has people who have been troubleshooting it for years, you already have the hardest ingredient: the domain knowledge. The tool just gives you a way to make it available at scale.

The knowledge base for this project started with five scenarios based on the most frequent support tickets. It now covers 31. Each new scenario takes roughly two to four hours to build out properly, including the edge cases. That is a reasonable investment for a scenario that generates 20 support tickets a month.

If you are building something similar for your Oracle user community, the questions, edge case structures, and session management patterns described here translate directly. The specific scenarios are where your team's expertise goes -- everything else is scaffolding.

How I Connected Oracle OCI LLM Endpoints to Postman and VS Code

I recently spent some time wiring up Oracle Cloud Infrastructure Generative AI endpoints so I could call models directly with an OCI Generative AI API key, validate everything in Postman, and then take the same setup into Visual Studio Code. The process ended up being a great example of how OCI can fit into modern AI workflows without forcing teams to abandon the tools they already use every day. Oracle’s Generative AI service supports service specific API keys, OpenAI compatible endpoints, and both Chat Completions and Responses APIs, which makes it much easier to integrate enterprise hosted models into familiar developer tooling.

What stood out to me most was how practical the setup became once the moving parts were understood. OCI Generative AI API keys are not the same as standard OCI IAM API keys. They are service generated secrets created specifically for OCI Generative AI, and Oracle documents that either of the two generated secrets can be used interchangeably in the Authorization header when calling supported model endpoints in the same region where the key was created.

Step 1: Creating the OCI Generative AI API Key

The first step was creating an API key inside the OCI Generative AI area of the Oracle Cloud console. Oracle documents these as service specific credentials for model access, and that distinction matters because they are meant for LLM endpoint authentication, not for general tenancy administration. Oracle also notes that the key must be used in the same OCI region as the model endpoint, which is important when you are testing against a region specific inference URL.

Another helpful detail is that OCI gives you two interchangeable secrets per API key. That makes rotation easier because one secret can be regenerated while the other remains active. Oracle explicitly recommends using one of those secrets as the bearer token when calling a supported model endpoint.

Step 2: Adding the IAM Policy That Makes the Key Work

Creating the API key was only part of the story. The key also needed permission to call the OCI Generative AI service. Oracle’s documentation explains that a separate IAM policy is required for principals of type generativeaiapikey, and this is where a lot of integration attempts can stall if the policy step is skipped.

In my case, I created the policy in the OCI Console under *Identity & Security > Policies* and used the manual editor in the root compartment. For testing, the policy that finally unlocked the flow was:

```text

allow any-user to use generative-ai-family in tenancy where ALL {request.principal.type='generativeaiapikey'}

```

Oracle documents this pattern for broad testing access and also explains that policies can be narrowed later by compartment, model, operation type, or even a specific API key OCID. That is a good way to start wide enough to validate the integration and then tighten the scope after the path is proven.

Step 3: Calling the OCI Endpoint from Postman

Once the key and policy were in place, I moved into Postman. Oracle documents a REST endpoint pattern for Chat Completions using OCI Generative AI API keys:

```text

https://inference.generativeai.<region>.oci.oraclecloud.com/20231130/actions/v1/chat/completions

```

Oracle’s API key documentation also shows that the request should send the API key secret in the Authorization: Bearer ... header and include a valid supported model in the request body. Supported models for this API key based REST path include xAI Grok and OpenAI GPT OSS, which are the models I focused on, but there's more available models in OCI like Llama, Cohere and Gemini.

My working request in Postman ended up looking like this:

```http

POST https://inference.generativeai.us-chicago-1.oci.oraclecloud.com/20231130/actions/v1/chat/completions

Authorization: Bearer sk-<your-secret>

Content-Type: application/json

Accept: application/json

```

With a body like this:

```json

{

  "model": "openai.gpt-oss-20b",

  "messages": [

    {

      "role": "user",

      "content": "Say hello in one sentence."

    }

  ]

}

```

After the policy was added, that request returned a successful response. That was the turning point because it confirmed the key, the policy, the endpoint, and the region were all aligned correctly. Oracle’s documentation supports this exact pattern, including the Chat Completions endpoint and the use of a bearer token generated by OCI Generative AI.

Click the image to expand it~

What I Learned From the Postman Troubleshooting

The troubleshooting was actually a useful part of the exercise. Early failures came down to a few very specific issues. First, the bearer token has to be the actual `sk-...` secret, not the API key OCID or a console URL. Second, the key has to be used in the same region where it was created. Third, the IAM policy really is required or the request will not succeed even if the secret is correct. Oracle’s docs are clear on all three of those points, and once those pieces clicked, the flow became much more predictable.

That experience also reinforced something broader. OCI is not just exposing models in its own console. Oracle is making the service available in ways that work with the tools many engineering teams already use, which lowers the friction to experiment and integrate. Oracle’s newer OpenAI compatible endpoint documentation makes that intent even more obvious by describing a base endpoint that works with familiar OpenAI style request patterns while still keeping authentication, execution, and resource management inside OCI.

Step 4: Taking the Same OCI Endpoint into VS Code

After confirming the endpoint in Postman, I wanted the same model access inside Visual Studio Code, given it's broad use in our organization. That turned out to be possible using VS Code’s bring your own key model support. Microsoft’s documentation explains that VS Code lets you add language models through the model picker and that custom providers can expose one provider with many models. The model metadata includes fields such as id, name, maxInputTokens, maxOutputTokens, and capability flags like tool calling and image input.

Using the custom endpoint option in the VS Code model picker opened a configuration file where I defined the OCI model settings. I used a Chat Completions style configuration because I had already validated that path in Postman. The key pieces were the OCI endpoint URL, the OCI API key, and the exact model ID. For example, openai.gpt-oss-20b worked well for a first pass because it had already succeeded in Postman, and Oracle lists GPT OSS as a supported model family for API key based Chat Completions.

The result was that I could select the OCI backed model in VS Code’s chat experience and use it like any other language model available through the model picker. Microsoft documents that the model picker is how users switch chat models, and Oracle documents that OCI supports both native and OpenAI compatible inference patterns. That combination is what made this work so well.

Click the image to expand it~

Why This Matters

To me, the bigger takeaway is not just that I got Postman and VS Code working. It is that OCI can participate in the same AI development workflows people already use for testing, coding, prototyping, and experimentation. Oracle’s documentation highlights support for OpenAI compatible endpoints, supported SDKs, and familiar APIs like Chat Completions and Responses. Microsoft’s documentation shows that VS Code is increasingly flexible about model choice through bring your own key and custom providers. Put those together and you have a path for teams that want enterprise hosted AI models without giving up developer ergonomics.

That opens up a lot of possibilities. It means OCI hosted models can be validated in Postman, consumed by scripts and SDKs, and surfaced directly in the editor where developers work. It also means organizations that are already invested in Oracle can extend that platform into modern AI workflows instead of treating it as something separate. OCI Generative AI is positioned by Oracle as an enterprise scale AI platform that supports hosted models, OpenAI compatible APIs, governance, and agent related features. This kind of integration work shows what that can look like in practice.

Final Thoughts

What started as a simple attempt to call a model with an OCI API key turned into a good exercise in understanding how Oracle has structured access, authorization, and compatibility with recent product enhancements. The final setup was straightforward once the pieces were in place: create the API key, grant the IAM policy, validate the endpoint in Postman, and then carry the same working endpoint into VS Code. Oracle’s API key model, policy framework, and OpenAI compatible options make that path realistic, and it is a strong example of OCI being useful well beyond the console itself.

If you are working in OCI and want to make enterprise hosted LLMs available in tools your team already trusts, this is absolutely worth trying.

Introducing My Microsoft Copilot Agent for Oracle ERP & HCM Metadata

Earlier, I shared a blog post detailing a Python-based CLI tool that leveraged Oracle Cloud HCM metadata and generative AI to provide SQL generation, metadata explanation, and table join suggestions. Building on that foundation, I’ve now brought the experience directly into Microsoft 365 using a Copilot Agent integrated with SharePoint.

This new solution allows users to interact naturally with metadata from Oracle ERP and HCM—without ever leaving the Microsoft ecosystem.

---

What This Copilot Agent Does

This Copilot Agent acts as a metadata consultant within your Microsoft 365 environment. It enables:

• Natural language discovery of relevant Oracle Cloud tables and columns
• Contextual SQL generation based on business terms
• Join recommendations using known key fields like person_id, assignment_id, etc.
• Explanations of tables, columns, and relationships
• Starter query generation for BI Publisher reports

---

Why CSV Metadata Format?

During development, I found that Microsoft Copilot currently does not support JSON-based data sources for grounding

As a result, I converted my metadata files to CSV format to ensure compatibility.

This included structured metadata for tables and columns sourced from both Oracle ERP and HCM Cloud.

---

Copilot Agent Instructions

Agent Purpose:

You are an intelligent enterprise metadata consultant designed to assist Oracle ERP and HCM users.
You use structured metadata stored in SharePoint to help users explore, understand, and query Oracle Cloud Applications datasets.

---

Behavioral Instructions (Copilot Agent):

Understand the Metadata:
Use metadata stored in the provided SharePoint folder:

ERP and HCM Tables Metadata

• Table_Metadata.csv: Contains table-level descriptions and possible usage context.
• Columns_Metadata.csv Contain schema-level information, including table name, column name, and column descriptions.

First load the Table_Metadata.csv, then load the Columns_Metadata files.
Use the shared table_Id to join columns to their corresponding tables.

---

Tasks You Can Perform:

• Suggest which tables or columns are most relevant to a user's query
• Generate optimized SQL queries based on natural language prompts
• Recommend joins using shared fields such as person_id, assignment_id, etc.
• Explain what a specific table or column is used for in business terms
• Summarize metadata for one or more objects when asked to “explain” or “describe”
• Help build starter queries for Oracle BI Publisher (BIP) reports
• Support semantic search (e.g., a search for "payroll balances" should find related metadata even if it’s not an exact match)
• Act as an expert Oracle Cloud ERP and HCM analyst and developer, capable of solving advanced metadata questions and building queries based on complex requirements

---

How to Complete the Tasks:

• Always refer to metadata found in the provided SharePoint files
• Never fabricate or guess metadata
• If no matching result is found, say: “I could not find relevant metadata for your request based on the provided files.”
• If the user provides multiple keywords (e.g., “payroll, salary”), treat them as individual context terms
• Scan for matches across both table names and descriptions and column descriptions
• Use exact column name and table name matches where possible
• Suggest joins using shared fields such as assignment_id, person_id, location_id
• Prefer documented relationships where available
• When generating SQL, use clear formatting and include comments if needed
• When a user says “HCM only” or “Exclude ERP,” make sure results match
• Clearly state which app (ERP or HCM) an object is part of when helpful
• When asked to return specific fields (e.g., “name, email, location”), find which columns correspond to those descriptions and which tables they belong to
• Ensure final responses are concise, technical, and clearly grounded in real metadata

---

Known Limitations

While this Copilot Agent adds tremendous value, it still has some important limitations:

• It can hallucinate: If metadata isn’t found due to vague prompts, the agent may fabricate plausible-sounding but incorrect information
• It requires clear prompting: Users get the best results when they use specific, well-structured queries
• File linking is not perfect: Even though metadata is grounded in CSV files, deep linking between them can still pose a challenge

Despite these caveats, the Copilot Agent demonstrates how far we can go by bringing structured enterprise metadata and AI together inside the tools we use every day.

AI Enhances Oracle Cloud HCM Support: Elevating Insight with the Oracle HCM Intel CLI

Oracle Gen AI + Public HCM Metadata = Limitless Insight

The Oracle HCM Intel CLI Tool is a professional-grade command-line assistant that uses your extracted HCM metadata and combines it with the capabilities of Oracle’s OCI Generative AI service (powered by Cohere) or OpenAI, or the LLM of your choice, giving you intelligent insights relative to HCM data structures. And it's all done securely and locally—no sensitive data leaves your environment.

By referencing public HCM data definitions, this project demonstrates just how powerfully Oracle Gen AI, and other AI offerings, can be applied in the enterprise to support analysts, developers, and architects with tasks such as:

• Generating SQL queries based on natural language
• Suggesting joins between key Oracle HCM tables
• Explaining and optimizing existing SQL
• Creating BI Publisher-ready templates
• Performing semantic metadata searches

Project GitHub: oracle_hcm_intel_cli

Demo: Watch Demo

---

Built With Practical Enterprise Needs in Mind

The tool includes features that any real-world implementation would benefit from:

• Encrypted .env handling using runtime secrets
• Markdown output for reporting or Copilot/Teams usage
• Audit mode for logging what metadata was passed to the LLM
• Modular provider support for OpenAI or Oracle Gen AI
• Interactive prompt chaining for analysts and non-developers

It’s optimized for real users working in real environments—offering flexibility without sacrificing security or precision.

---

Powered by Oracle Technology, Honoring Oracle’s Vision

This CLI tool is powered by Oracle’s own public documentation and showcases the capabilities of Oracle Cloud Infrastructure’s Generative AI platform. It's a clear example of how AI and metadata can be responsibly applied in the enterprise, especially when building tooling around Oracle’s HCM ecosystem.

Oracle’s Gen AI service is the star of the show here—it brings context, comprehension, and creative query generation to the hands of business users and technical professionals alike.

Earlier this month, I introduced a Metadata Extractor CLI Tool built to programmatically parse Oracle Cloud HCM’s public documentation and extract table and view metadata into JSON format. That foundational tool—available on GitHub at oracle_hcm_metadata_extractor—has enabled this powerful second act: the Oracle HCM Intel CLI.

---

Get Started

1. Extract metadata using: oracle_hcm_metadata_extractor

2. Query and explore with: oracle_hcm_intel_cli

Whether you’re working in HCM data architecture, reporting, or support—this is your AI-powered sidekick.

---

I hope this project inspires others to build upon Oracle’s cloud platform and apply Generative AI responsibly. The future of enterprise tooling is intelligent, secure, and deeply integrated—and with Oracle Gen AI, that future is now.

—
Julio @ OracleSpot.net

Supercharging Oracle HCM Research and Support with a CLI Tool to Obtain Structured Documentation Metadata

As an Oracle Cloud HCM customer and practitioner, I frequently rely on the Oracle Cloud Applications Documentation to understand how various tables and views are structured. Whether I’m building BI Publisher queries, supporting Fast Formulas, or troubleshooting integrations, knowing the exact column names and their meanings is essential.

But manually digging through dozens (or hundreds) of HTML pages is time-consuming and repetitive.

So, I decided to automate it in a way that would allow me to have conversations with this data versus clicking through hundreds of pages aimlessly looking for answers.

What I Built

I created a Python-based command-line tool that extracts Oracle's publicly available HCM documentation, regarding tables and views, and outputs structured metadata for tables and views into clean JSON files. This helps streamline research, improve automation, and accelerate troubleshooting for internal support.

Here’s what it does:

• Parses the toc.js file from Oracle’s documentation site to extract all table/view URLs

• Visits each documentation page using a headless browser

• Extracts metadata such as:

  • For Tables: table name, description, details, columns (with data types), primary keys, and indexes

  • For Views: view name, description, details, column names, and SQL query

No more flipping through documentation pages—just clean, structured data ready for analysis or integration into support tools, with many useful use cases including those in the AI landscape.

---

How It Works

Step 1: Extract Links from toc.js

The Oracle documentation includes a toc.js file which holds all the links to individual table and view pages. The tool first parses that file to build a list of URLs.

python oracle_hcm_cli_tool.py --toc toc.js --csv oracle_links.csv

Step 2: Convert CSV to JSON

For downstream processing, the CSV is converted to a simple JSON array of {name, url} pairs.

python oracle_hcm_cli_tool.py --csv oracle_links.csv --json oracle_links.json

Step 3: Extract Table and View Metadata

The final step launches a headless browser with Playwright and visits each page to extract structured metadata.

python oracle_hcm_cli_tool.py --json oracle_links.json --tables 

oracle_tables.json --views oracle_views.json

Or all three steps in one:

python oracle_hcm_cli_tool.py --toc toc.js --csv oracle_links.csv 

--json oracle_links.json --tables tables.json --views views.json

---

Output Format

Here’s what the output looks like.

For Tables (tables.json)

{
  "table_name": "PER_ALL_PEOPLE_F",
  "url": "...",
  "description": "This table stores information about...",
  "details": "Schema: FUSION Object owner: PER Object type: TABLE Tablespace: APPS_TS_TX_DATA",
  "columns": [
    {
      "column_name": "PERSON_ID",
      "data_type": "NUMBER",
      "length": "",
      "precision": "18",
      "not_null": true,
      "description": "System generated surrogate key"
    },
    ...
  ],
  "primary_key": {
    "name": "PER_PEOPLE_F_PK",
    "columns": ["PERSON_ID", "EFFECTIVE_START_DATE", "EFFECTIVE_END_DATE"]
  },
  "indexes": [
    {
      "name": "PER_PEOPLE_F_U1",
      "uniqueness": "Unique",
      "columns": ["BUSINESS_GROUP_ID", "PERSON_NUMBER"]
    }
  ]
}

For Views (views.json)

{
  "view_name": "FAI_DEEP_LINKS_VL",
  "url": "...",
  "description": "This view shows deep link metadata...",
  "details": "Schema: FUSION Object owner: FAI Object type: VIEW",
  "columns": [
    { "column_name": "DEEP_LINK_ID" },
    { "column_name": "DEEP_LINK_CODE" },
    ...
  ],
  "sql_query": "SELECT ... FROM FAI_DEEP_LINKS_B b ..."
}

---

Why This Is Useful

This tool is a game-changer if you:

• Frequently need to understand Oracle's schema to troubleshoot or write custom reports

• Work in integrations, BI, or payroll support and need faster insights

• Want to build dashboards or internal tools that visualize schema metadata

• Need a starting point for building generative AI agents or search interfaces that utilize documentation in order to drive intelligent insights

• This same approach can be followed for Oracle ERP, and other use cases, for Oracle customers

---

⚠️ Disclaimer

Disclaimer: 

This tool and blog post are independently created for research, education, and internal productivity enhancement by an Oracle customer. 

All references to Oracle® products and documentation are made strictly for educational and interoperability purposes. 

Oracle, Java, and MySQL are registered trademarks of Oracle and/or its affiliates. 

This tool is not affiliated with, endorsed by, or sponsored by Oracle Corporation.

Metadata shown (such as table names and column names) are extracted from publicly accessible Oracle documentation. 

No proprietary documentation or licensed software is redistributed or reproduced in full.

Always refer to Oracle Cloud Documentation for official and up-to-date content.

---

Want to Try It?

You can clone the tool and try it for yourself:

https://github.com/TheOwner-glitch/oracle_hcm_metadata_extractor

Happy automating!

Introducing the Oracle HCM Fast Formula Agent – Built with AI to Help You Work Smarter

Introducing the Oracle HCM Fast Formula Agent – Built with AI to Help You Work Smarter

After months of juggling fast formulas, fielding questions from HR teams, and trying to decode cryptic payroll logic at 2AM, I decided it was time to build something better.

Today, I'm happy to share an open-source project that came from that journey:

Oracle HCM Fast Formula Agent – A smart, simple tool that uses Generative AI to help you generate, validate, explain, and modify Oracle HCM Fast Formulas, and more!

Check out a quick demo - Watch on Loom

Why I Built It

Working in the Oracle Cloud HCM space, I saw firsthand how challenging it can be to:

• Interpret legacy Fast Formulas written years ago
• Validate logic across hundreds of conditional paths
• Explain formula outcomes to business users
• Generate new formulas based on complex rules, under tight deadlines

And with the rise of AI, I thought: Why not build an assistant that understands Oracle HCM and speaks "formula"?

What It Does

With this Flask-based app, you can:

✅ Generate new Fast Formulas from plain-English descriptions
✅ Explain existing formulas in readable, line-by-line language
✅ Validate and suggest corrections for logic/syntax errors
✅ Modify formulas based on user input
✅ Extend the tool with new advanced actions using a plugin system, like the included Summarize advanced action!

It even has a clean admin panel and a dark mode toggle because... well, late-night debugging deserves a good theme.

📦 Plugin Architecture

Want to add your own action like summarize_formula or compare_logic_blocks? Just drop it in the plugins/ folder. No changes to the main app required. It's built for extensibility.

🐳 Docker Ready

Whether you’re developing locally or deploying in the cloud, the app comes with a Dockerfile that runs the app via Gunicorn for production-grade performance.

🔗 Get Started

Clone it, run it, or fork it for your own use:

👉 GitHub: https://github.com/TheOwner-glitch/hcm-fast-formula-agent
📹 Demo: Watch the video

A Call to the Oracle Community

I built this for consultants, analysts, and developers who need to move fast and support critical Oracle HCM needs in the Fast Formula space, but more importantly to share an example of how AI Powered application development can be compelling and reduce the need for conditional and hardcoded business logic by instead leveraging the power of generative AI  to interpret natural language. If you try it out and find it helpful, or have ideas for improving it, I’d love to collaborate.

Thanks for reading. Now go automate your fast formula headaches away.

- Julio

Leveraging Oracle Cloud’s Generative AI with Cohere: A Hands-On Approach

After days of tinkering and fine-tuning, I'm excited to share something I’ve been working on — OCI Generative AI Cohere Integration with external services. If you're someone who works with AI, Oracle Cloud, or just enjoys diving into new tech, this project might be something you'll find interesting.

What's the Project About?

In short, it's a simple yet powerful integration of Oracle Cloud’s Generative AI service with Cohere's language model by exposing it to external usage in order not to be confined to the chat experience within the OCI console. The goal is to provide an easy-to-use interface for AI-driven responses via a Flask API or function-based approach. Whether you're running the service locally or integrating it into your own applications, this project is meant to be a starting point for building smarter, AI-powered experiences that allow you the flexibility of using your preferred development platform outside of the playground in your Oracle OCI Tenancy.

Why This Project?

If you’re like me, you enjoy playing with new tools but don’t always want to reinvent the wheel every time you build something. That’s why I wanted to simplify integrating Oracle's powerful AI services into everyday applications. The project takes the heavy lifting out of the process and provides a clean, easy-to-use API for interacting with Oracle’s AI models.

But it doesn’t stop there. Whether you're building out something bigger or just playing around with ideas, this project is designed to be flexible and easily extendable.

Here’s What You Get:

• Flask API: If you’re building a web-based application and want easy interaction with the Generative AI service, the Flask API is ready to go. You can send requests, get responses, and scale up as needed.
• Function-based API: For those who don’t need a full web API, you can call the AI service directly from a function that you can import into your Python projects. Perfect for smaller integrations or experimenting within your own apps.
• Configuration Flexibility: With environment variables and a configuration file, you have full control over things like model parameters and Oracle Cloud credentials.

How to Use It?

1. Set up your environment: Whether you're using the Flask API or the function-based setup, you’ll need to configure your environment with Oracle Cloud credentials and some basic settings.
2. Get running: Once configured, you can easily call the API or function with any message you want to send to the AI model, and you’ll get a detailed response in return.

I’ve added full instructions on the project’s GitHub page, including setup steps, environment variables, and how to run both approaches.

What’s Next?

The goal is to keep expanding this project. Right now, it’s all about integration, but as AI services evolve, I want to keep adding new features and I likely will build apps that consume these interfacing endpoints in order to use the power of the Cohere LLM. Expect more updates on this as I add new functionality and more tutorials to help everyone get the most out of the platform.

Feel free to dive into the project, contribute, or just ask questions. I’m always happy to connect with fellow developers who are exploring AI and Oracle Cloud.

Check it out on GitHub: OCI Generative AICohere Integration

I've added some screenshots below showing the interactions with the OCI Gen AI service via Postman by utilizing the Flask API, allowing extensibility outside of the chat experience in OCI which is the default experience. 

By utilizing the API approach you can take advantage of the power of the Cohere LLM through Oracle OCI in your applications and data science tools while maintaining your security assurances of being inside of your OCI tenancy.

Thanks for reading, and happy coding!

OCI Gen AI Playground

Click on the images to expand them for ease of viewing

Postman Interaction with Flask API Exposing the OCI Gen AI Chat Service

OCI Gen AI Traffic from the API

How to Create and Manage a Microsoft Teams Copilot Agent

Creating and managing a Teams Copilot Agent can significantly enhance your team's productivity and streamline various tasks. In this blog post, we'll walk you through the steps to set up and configure your agent, along with some useful tips to optimize its performance.

Pre-requisites

Before you start, ensure you have access to Copilot in Teams. You may need to be part of the ACL Group that manages access to the agent. Additionally, users in this group must have access to the SharePoint folder where the source data is located.

Step-by-Step Guide

1. Navigate to Copilot in Teams

In Teams, go to the Copilot section under "Chats."

2. Create an Agent

Click on "Create an Agent" and then select "Configure."

3. Select a Template

You can choose a template that will auto-populate instructions and other fields. These instructions essentially define the persona your agent will assume.

Tip: Pick a template of the kind of agent you want, then place the instructions template in ChatGPT or Copilot or OCI Gen AI and ask it to create a persona based on a given context of your choosing.

4. Point the Agent at Source Data

In the "Knowledge" section, point the agent at the source data. Place the files that will serve as the content for the agent in SharePoint or Teams. You can add up to 20 sources in SharePoint.

Tip: Avoid versioning files; store the latest version of the document. Organize the content and folders the agent is pointing to for higher accuracy.

5. Configure Agent Capabilities

If you want to build an agent that generates images or writes code exclusively, check the respective boxes. For a general-purpose conversational agent, leave these boxes unchecked.

6. Set Starter Prompts

These are prompts users will see when they start a conversation with the agent. You can hardcode common prompts to get users started.

7. Create the Agent

Once all the information is filled out, hit "Create" (top right).

8. Set Access Controls

Enter the ACLs to expose the agent to specific users. Copy the link to the agent and share it with the people who will access it (they also need to have Copilot).

Tip: Individual users may not work depending on your company policies; only ACL groups.

Editing an Agent

To edit an agent, go back to "Create an Agent," click on "View all agents," and navigate to the one you want to edit. You can change the instructions or access settings as needed.

If you are using Microsoft Teams, you can create very useful Agents on top of your existing data and make research, discovery and troubleshooting more engaging, it is a great way to assist new employees or help enhance productivity in general!

Leveraging the Oracle Autonomous Database and AI for Effective Content Moderation in Online Communities

Today, managing online communities and forums can be a daunting task. From duplicate questions to unaccepted answers, and from unchanged idea statuses to duplicate ideas, the challenges are numerous. Even with active management, the manual effort required by product teams can be overwhelming. However, AI-driven content moderation offers a promising solution to these pain points. In this blog post, we'll explore how AI can be used to streamline content moderation and enhance the user experience in any online community.

Addressing Duplicate Content

One of the most common issues in online communities is the presence of duplicate ideas or questions. Here's a methodology to tackle this problem using the Oracle ADB and Gen AI Service in OCI:

1. Database Integration: Connect your community's database to an AI service. For instance, if your community is hosted on an autonomous database (ADB), you can set up a trust between the ADB and an AI service (like the OCI Gen AI Service) natively.
2. Creating Views: Develop views that represent the community categories, containing idea numbers, names, and descriptions, for example, as metadata for the AI Service to utilize.
3. AI-Powered Duplicate Detection: Create a stored procedure (API) that calls the AI service to identify similar ideas/questions already created. Based on a predefined accuracy/confidence level, the AI can flag potential duplicates.
4. Automated Comments: Develop an API to automatically comment on flagged ideas, informing users about the duplication and providing links to similar ideas or threads.
5. User Feedback and Model Training: Allow users to challenge the duplicate flag. These challenges can be used to train a custom model over time (you can start with Oracle's AutoML feature with very low effort), improving accuracy with minimal effort. This would be done at the client end.
6. Nightly Jobs: Schedule nightly jobs to run within the database to perform this true-up, using AI services and APIs to perform regular content moderation.

Enhancing Search Validation

To further strengthen content moderation, consider the following steps:

1. REST Enablement: REST enable the stored procedure API using a service like Oracle Rest Data Services (ORDS), which is native within the ADB.
2. Improved Search Validation: Integrate this API as a validation step when users create new ideas or questions in your website or app. This step can enhance the existing search validation by considering different languages, descriptions, and metadata, ensuring a more accurate detection of duplicates.

Flagging Existing Capabilities

Another opportunity for AI-driven content moderation is to flag ideas/questions/enhancements that suggest features already available in your product:

1. Repository Integration: Expose a repository of current capabilities to the AI service.
2. Automated Comments: Develop an API to automatically comment on flagged ideas, providing links to documentation and informing users about existing features.

Conclusion

AI-driven content moderation offers a powerful solution to the challenges faced by online communities, including for product teams that crowdsource content to improve their software solutions. By leveraging AI, communities can reduce manual effort, enhance user experience, and ensure more accurate and efficient content management. Whether it's detecting duplicate content, improving search validation, or flagging existing capabilities, the ADB and OCI Gen AI Service can transform the way online communities are managed, driving growth and success.

Oracle Application Express (APEX) - Generative AI Capabilities

Oracle Application Express (APEX) continues to revolutionize the way developers create web applications with its new Generative AI assistant. This cutting-edge feature integrates artificial intelligence into APEX’s low-code environment, allowing developers to accelerate the development process like never before. With the APEX Generative AI assistant, users can now generate SQL queries, PL/SQL and JavaScript code, and even create applications simply by describing their requirements in plain language. This means less time spent writing code and more time focused on refining application logic and design.

By bridging the gap between natural language and complex code generation, the AI assistant significantly reduces the learning curve for new developers while enhancing the efficiency of experienced ones. As Oracle APEX continues to evolve, the inclusion of AI-powered features sets a new standard for rapid application development, providing a powerful toolset that enhances productivity and creativity across all skill levels.

This introduction of generative AI in APEX showcases Oracle’s commitment to integrating advanced technologies that make development more accessible, efficient, and intuitive. Whether you're a seasoned developer or just beginning your journey with APEX, the Generative AI assistant opens up new possibilities for creating robust, data-rich applications faster than ever before.

Let us take a look at how to setup the Generative AI feature and what are some of the uses cases!

Note: click the images below to expand them for ease of use and readability! 

Setup

In order to take advantage of these features, we need to allow APEX to interact with an LLM via the API layer, and to do that we want to navigate to the "Workspace Utilities" area then select the "Generative AI" option.

Once we are there, you can create a trust between your APEX instance and an LLM, in the screenshot below we see the trust setup with Open AI, using an API key that I have access to, and I also show the options available to you besides Open AI, which are Cohere and Oracle's OCI Generative AI Service (which I recommend specially if you already use Oracle Cloud Infrastructure, to take advantage of all the security you already have in place in your Virtual Cloud Network!).

APEX Assistant - SQL Workshop

Now for the exciting part! Within the SQL Workshop, you will see an option to click on the "APEX Assistant" which will open a panel on the right side, allowing you to access the query builder feature!

In the above we see the assistant joining two tables for us, in this example! We simply asked whether two tables in the current schema could be joined, and it provided the SQL statement to do just that! This can be very useful when seeking assistance in writing complex SQL for a data lineage you may not be very familiar with, and it is also something you cannot easily accomplish in another tool, like Chat GPT, because the APEX Assistant has access to the metadata in your database directly, making things easier!

Besides the query builder feature, we have the general assistance mode, where we can ask it to develop code for us, modify and optimize code, etc. In this example we ask it to write a PLSQL stored procedure:

Notice how the "insert" feature will drop the code provided into your development canvas automatically!

In this next example, we switched the language to JavaScript, and asked a question a bit more complex:

Create Applications using Gen AI

Besides the AI Assistant in the SQL Workshop, there's another very useful feature, this time in the App Builder!

Here another option is introduced, to use a conversational agent to generate apps, in addition to existing options like creating an app from a file!

This is a powerful feature to get you started with your application, and I am excited to see how it evolves in the feature allowing for more customization and increased usability, but it is definitely a step in the right direction!

Conclusion

As we saw, there's plenty of new features to be excited about in the way of Generative AI within APEX, and I am very excited to see how these features evolve over time, but they are certainly already powerful, particularly the Assistant in the SQL Workshop, and if you use APEX already, there is no reason not to jump on these very cool features!

Oracle AI Documentation and Information

Everyone knows that AI and ML are the trending topics, and Oracle is certainly investing heavily relative to their own AI strategy.

The below links to information are great resources relative to AI documentation and information that Oracle has made available, and should definitely be explored for anyone interested in seeing what Oracle has to offer in this space!

1.      AI Overview - OCI Generative AI service provides customizable large language models (LLMs) that cover a wide range of use cases for text generation.

https://docs.oracle.com/en-us/iaas/Content/generative-ai/overview.htm#overview

2.      Concepts for Generative AI - concepts and terms related to the OCI Generative AI service

https://docs.oracle.com/en-us/iaas/Content/generative-ai/concepts.htm

3.      PII Data with AI – How to safeguard the corporate jewels and sensitive customer data when using AI

https://orasites-prodapp.cec.ocp.oraclecloud.com/site/ai-and-datascience/post/rotect-pii-customer-data-ads-pii-operators

4.      Oracle AI GitHub Repository -   Great examples of LLM’s and AI services with step by step code examples with OCI AI services

https://github.com/oracle-samples/oci-data-science-ai-samples/

5.      Live Labs – 40 Hands on Labs for AI services and related services. This is a great source for any Oracle Technology or product https://apexapps.oracle.com/pls/apex/dbpm/r/livelabs/livelabs-workshop-cards?session=108343633199478

6.      Oracle AI and Data Science YouTube Channel – 

https://www.youtube.com/playlist?list=PLKCk3OyNwIzv6CWMhvqSB_8MLJIZdO80L

7.      OCI Data Science Landing Pad – starting point for setting up a OCI tenancy using the Data Science Service.  Step by Step for setting up service, creating models, and submitting jobs

https://docs.oracle.com/en-us/iaas/data-science/using/home.htm

8.      Embedded AI and ML capabilities in Oracle Analytics -

https://orasites-prodapp.cec.ocp.oraclecloud.com/site/ai-and-datascience/post/discover-the-power-of-oracle-analytics-with-ai

9.      Oracle Analytics Cloud and AI for Business Users –

https://www.oracle.com/business-analytics/analytics-platform/capabilities/ai-ml/

10. Intro to Select AI in Autonomous DB - 

https://blogs.oracle.com/machinelearning/post/introducing-natural-language-to-sql-generation-on-autonomous-database

11. Select AI -  Use Select AI to Generate SQL from Natural Language Prompts

https://docs.oracle.com/en-us/iaas/autonomous-database-serverless/doc/sql-generation-ai-autonomous.html#GUID-9CE75F94-7455-4C09-A3F3-118C08E82B7E

12. Machine Learning Blog Page – This Blog Homepage is focused on AutoML generating code for SQL, Python, and R

https://blogs.oracle.com/machinelearning/

13. Machine Learning Documentation for SQL, Pyton, R, Spark

https://docs.oracle.com/en/database/oracle/machine-learning/index.html

14. Machine Learning Technical Replays and Office Hours

https://asktom.oracle.com/ords/r/tech/catalog/series-landing-page?p5_oh_id=6801#sessions

15. LiveLabs Hands on training for Machine learning

https://apexapps.oracle.com/pls/apex/f?p=133:100:8251167255223::::SEARCH:machine%20learning

Oracle OCI Gen AI Services and Enhancing Developer Productivity

Let’s talk about Oracle’s OCI Gen AI Service, Generative AI Service | Oracle [oracle.com], in the context of the developer productivity opportunities that exist because of it which can transform development shops to be more efficient all-around!

I am currently exploring the OCI service for areas such as the below, and will write a follow-up entry relative to my findings:

• Code generation and auto-completion: With generative AI, the potential to write code using AI to greatly speed up building extensions and integrations will be a game changer, much like how data scientists can now write R & Python code exponentially faster using ChatGPT like services, so can writing extensions and integrations become far less manual for you.
• More time could be spent on design, unit testing and other aspects versus manual development.
• Code refactoring & bug fixing: Asking the AI to code review, improve, make suggestions around implementation for custom code is something already available for high code programming languages like C#, Python, PLSQL and Java in tools like ChatGPT, and this can increase quality and reduce bugs.
• You can embed AI reviews to your peer review process, as well as during the build process to optimize performance and reduce logic errors.
• To help with KT’s when flexing with staff or when a developer is touching a code base they did not previously own, the developer can ask the AI service to explain logic, speeding up the learning process exponentially.
• Automated Test Generation: having the ability for the AI to generate test scenarios and test cases, in supported frameworks, based on the implementation and logic would save time and reduce defects.
• We can ask the AI to interpret code and suggest unit test scenarios and even build them (depending on the framework).
• Code comparisons: rather than using tools like Beyond Compare, to manually inspect differences in code bases, you can ask the AI to inspect it for you and produce a comparison report with intelligence built in (meaning, really explain what is different, not just highlight text differences).
• Code notation & summarization: imagine uploading code to the AI service and asking for a detailed implementation report with steps and explanations, and even a technical design and graphical support such as sequence diagrams.
• This would be very helpful for custom code where technical designs were not clearly documented or not documented at all (more prevalent now due to the Agile methodology putting less emphasis on documentation) and useful for onboarding new developers and support staff, for product delivery to hand off artifacts to operations, etc.
• The time savings from not having to write detailed technical designs would be fantastic, and in general to speed up any developer working on a case by asking the AI to summarize and explain sections of the code.

I can produce many other scenarios, but I think I’ve made my point.

So, why Oracle since there’s similar services in the industry? I believe the Oracle services can have a competitive advantage because Oracle AI data models should yield higher accuracy with frameworks such as Oracle JET, Java, PLSQL, Fast Formulas, etc. since Oracle owns those frameworks and uses the AI service internally as part of their own DevOps processes, and the AI model could learn overtime as your developers utilize the service, and it would learn from usage, on top of Oracle’s tuning of the service over time. Lastly, it would be within your secure VCN and OCI environment, so privacy and security should not be a concern if you already have an OCI tenancy, and this is a major factor for many wishing to adopt Gen AI safely.

I think the usage of this, for the moment, is limited to high code frameworks such as Java, PLSQL, C#, Oracle JET (JavaScript), Python etc. but we would be very interested in extending the usability and benefits to middleware technology such as Oracle Integration, for the same reasons listed in this blog.

To that end, I have raised an Idea in Customer connect for the integration of the OCI Gen AI Service to Oracle Integration Gen 3 (OIC) going back to September of last year, so please support this idea over in Cloud Customer Connect by voting and commenting on it (Idea Number: 713448): Generative AI for OIC — Cloud Customer Connect (oracle.com) [community.oracle.com]

Stay tuned for my findings over the next few weeks, as I explore the Gen AI service for these use cases!

Oracle Generative AI Strategy and Options

The software industry continues to innovate and iterate upon AI capabilities, and Oracle is clearly investing heavily in this space as well, with very exciting developments being announced recently.

Below are highly informative strategy updates that you may want to review relative to Oracle’s AI strategy and recent developments.

• Oracle Generative AI Strategy Update - Oracle Generative AI Strategy Update (youtube.com)
• From Greg Pavlik (SVP, Oracle AI) - Posted 2 weeks ago
• Highly recommended to watch, includes an interview with Deloitte's global head of Oracle and AI, also includes a brief conversation with Miranda Nash (GVP App Dev and Fusion AI at Oracle)
• First Principles: Exploring the Depths of OCI Generative AI Service: https://youtu.be/TOPaqzM7u5s?si=rUJIF5Toq7h0XCVG [youtu.be]
• From Pradeep Vincent, SVP Chief Technical Architect, OCI
• Cohere and Oracle Partnership Brings Generative AI Solutions to Customers | Oracle Cloud World 2023 (youtube.com)

The below graphic shows Oracle's AI Technical Stack and where recent investments have been made:

Click on the image to maximize it

These AI services are the same used by Oracle internally to develop AI capabilities in the Fusion applications and Fusion analytics, etc. now exposed for customers to utilize as well.

Something that Greg mentions in the first video, is the GenAI Agents beta recently launched, that is a service that allows you to have a conversation with your data within your autonomous database. Also, there's a new feature now called "Autonomous database select AI", also seen above, here's a GREAT blog about it: Introducing Select AI - Natural Language to SQL Generation on Autonomous Database (oracle.com)

I think that both the GenAI Agents and the Select AI feature should be considered as part of any modern Data Strategy, particularly when the data sources are Oracle applications (such as ERP & HCM), once your Autonomous Datawarehouse (ADW) has the Fusion data in it via BICC, you can use these features there without moving the data to a third-party tool to do similar operations (which can increase your cost of ownership and decrease technology technical stack harmony (meaning using too many vendor products unnecessarily)).

Imagine transforming part of your workforce from writing reports to being able to have conversations with the data without A) Having to move it elsewhere B) Having to spend a lot of time writing complex queries and designing intricate reports. Their workload could shift from designing and building reports, to tuning the data model and talking with the data, and this could then be expanded to end users over time, where internal teams would then focus on data model tuning, and everyone else is just talking with the data.

Additionally, this would all be happening within the secure boundaries of your OCI tenancy, reducing concerns around privacy and security that often worries the mind!

Real life examples for those using ERP and HCM that could be made possible in the near future:

%sql

SELECT AI how many invoices are past due

SELECT AI how many suppliers do we consistently not pay on time, and what are the reasons

SELECT AI how many expenses will be past due by next week

SELECT AI how many people under my organization may retire over the next 5 years

SELECT AI how many people under my organization will lose vacation by end of year

No more reports, just conversations with the data..!