Créez des agents autonomes avec Select AI Agent

Sélectionnez AI Agent (cadre d'agent autonome) pour créer des agents interactifs et autonomes dans Autonomous AI Database, combinant planification, utilisation d'outils, réflexion et mémoire pour fournir des flux de travail multitours.

Note :

La prise en charge de Select AI Agent et de l'ensemble DBMS_CLOUD_AI_AGENT est disponible dans Oracle Database 19c à partir de la version 19.29 et dans Oracle Database 26ai à partir de la version 23.26.

Rubriques connexes

À propos de Select AI Agent

Select AI Agent (cadre d'agent autonome) est un programme permettant de créer et de gérer des agents interactifs et autonomes dans une base de données autonome sur l'IA. Les agents raisonnent sur les demandes, appellent des outils, réfléchissent aux résultats et maintiennent le contexte avec une mémoire à court et à long terme alimentée par un profil d'IA spécifié pour le LLM avec le modèle agéntique ReAct (Reasoning and Acting).

Select AI Agent permet l'utilisation d'outils intégrés tels que la RAG et le langage naturel vers SQL (NL2SQL), des procédures PL/SQL personnalisées et des API REST externes pour effectuer des tâches. La structure conserve la mémoire multi-tours, en maintenant le contexte entre les conversations. Ensemble, ces capacités prennent en charge une IA générative évolutive et contextuelle qui s'intègre aux données et aux flux de travail de l'entreprise.

L'ensemble DBMS_CLOUD_AI_AGENT encapsule les limites de gestion, d'orchestration et de sécurité. Pour plus de détails, voir Ensemble DBMS_CLOUD_AI_AGENT.

Caractéristiques de Select AI Agent

Les principales caractéristiques comprennent une intelligence intégrée, des outils flexibles, des conversations tenant compte du contexte et un déploiement plus rapide.

  • Intelligence intégrée :

    Combine la planification, l'utilisation des outils et la réflexion afin que les agents puissent raisonner sur les tâches, choisir et exécuter des outils, observer les résultats, ajuster les plans et améliorer les réponses tout au long de la conversation. Les agents planifient les étapes, exécutent des outils, évaluent les observations et mettent à jour leur approche lorsque les résultats ne répondent pas aux attentes. Cette boucle renforce la précision, réduit le réusinage et maintient les conversations sur la bonne voie.

  • Outillage flexible :

    Prendre en charge la RAG et NL2SQL intégrés, les procédures PL/SQL personnalisées et les services REST externes, sans composants d'orchestration ou infrastructure distincte, afin de conserver la logique de base de données tout en intégrant des capacités externes, le cas échéant.

  • Conversations en fonction du contexte :

    Maintenez une mémoire à court et à long terme pour garder le contexte dans les virages, personnaliser les réponses, stocker les préférences et prendre en charge le contrôle humain en boucle pour les corrections et les confirmations lors de sessions multitours. La mémoire à court terme maintient le dialogue actuel cohérent. La mémoire à long terme enregistre les préférences et les résultats antérieurs, soutenant les interactions de suivi et la surveillance par les évaluateurs humains.

  • Évolutivité et sécurité :

    Exécutez la base de données Autonomous AI Database, héritez de ses contrôles de sécurité, de ses vérifications et de sa performance, réduisez le déplacement des données et normalisez la gouvernance pour les déploiements d'entreprise et les environnements réglementés à grande échelle. Les agents bénéficient des caractéristiques de sécurité, d'audit et de performance des bases de données. Le fait de garder le traitement proche des données réduit les mouvements et s'aligne sur les pratiques de gouvernance.

  • Développement plus rapide :

    Définissez des agents, des tâches et des outils avec SQL et PL/SQL familiers, réutilisez les procédures existantes et expédiez les fonctionnalités plus rapidement tout en gardant la logique proche des données opérationnelles et des équipes sans créer d'infrastructure distincte.

ReAct Modèle agéntique

Select AI Agent utilise le modèle agentique ReAct (Reasoning and Acting) où l'agent motive la demande, choisit des outils, effectue des actions et évalue les résultats pour atteindre un objectif.

Voici le modèle pour chaque itération :

  1. Interrogation : L'utilisateur pose une question ou émet une demande. L'agent le lit, extrait les détails clés et se prépare à planifier les étapes suivantes.

  2. Pensée et action : L'agent raisonne sur les options, choisit un outil et l'exécute pour collecter des données ou modifier l'état selon les besoins de la tâche.

  3. Observation : Les observations incluent les résultats d'outil ou d'interrogation, les messages de confirmation et les erreurs. Ceux-ci deviennent des entrées dans le prochain cycle de raisonnement de l'agent. L'agent enregistre les observations et vérifie si les résultats prennent en charge l'étape suivante ou la réponse finale.

  4. Réponse finale : Après suffisamment de pensées et d'observations réussies, l'agent compose une réponse claire, explique les décisions importantes et partage les prochaines étapes ou actions de suivi.

Sélectionner une architecture d'agent d'IA

Sélectionnez AI Agent pour organiser le travail en quatre couches : Planning, Tool Use, Reflection et Memory Management. Ces couches coordonnent le raisonnement, les exécutions d'outils, l'évaluation et les interactions multi-tours contextuelles.

Planification : Planning interprète la demande de l'utilisateur, la décompose en actions ordonnées, sélectionne les outils candidats et rédige un plan à l'aide du contexte de session, des résultats précédents et des connaissances pertinentes. L'agent analyse la demande, identifie les détails manquants et propose une séquence ordonnée d'actions. Il choisit des outils qui correspondent aux politiques, à la portée des données et aux résultats attendus.

Utilisation de l'outil : l'utilisation de l'outil sélectionne et exécute l'outil pour chaque action. Les types pris en charge sont la RAG, NL2SQL, les procédures PL/SQL personnalisées pouvant être ajoutées lorsque vous créez un outil et des services REST externes tels que la recherche Web et le courriel. Chaque étape appelle un outil avec des paramètres. Les outils intégrés gèrent l'extraction et la génération SQL. Le code PL/SQL personnalisé encapsule la logique du domaine. Les outils REST se connectent à des services externes.

Réflexion : La réflexion évalue les résultats de l'outil par rapport aux attentes et passe à la réponse finale. L'agent compare les observations à l'objectif. Si les résultats semblent erronés ou s'il y a des erreurs d'appel d'outil ou des résultats désapprouvés par l'utilisateur, l'agent révise le raisonnement, choisit un autre outil ou met à jour le plan avant de réessayer. Lorsque les résultats ne correspondent pas, il ajuste le plan, sélectionne différents outils ou peut poser des questions de clarification avant de continuer. Vous pouvez interroger les pensées de l'agent d'intelligence artificielle à l'aide de USER_CLOUD_AI_CONVERSATION_PROMPTS. Pour plus d'informations, voir Vues DBMS_CLOUD_AI.

Gestion de la mémoire : La gestion de la mémoire stocke le contexte de session et les connaissances par équipe d'agent. La mémoire à court terme contient des messages récents et des résultats intermédiaires par équipe d'agent. La mémoire à long terme enregistre les préférences, l'historique et les stratégies, améliorant ainsi la continuité, la personnalisation et la planification. La mémoire à long terme conserve des connaissances utiles dans toutes les sessions, améliorant ainsi l'orientation et la qualité des réponses au fil du temps entre les équipes d'agents.

Sélectionner une terminologie d'agent d'intelligence artificielle

Explorez les concepts et les termes liés à Select AI Agent (cadre d'agent autonome).

Les termes suivants sont liés à Select AI Agent :

Terme Définition
Action agénétique

Dans le contexte des agents, une action est une instruction qui déclenche un outil avec des paramètres. La plate-forme exécute l'outil, gère les erreurs et renvoie une observation pour la prochaine boucle de l'étape de raisonnement.

Les actions relient la planification à l'exécution. Ils définissent quel outil exécuter et avec quelles entrées.
Agent

Un agent effectue des tâches à des fins définies. Un agent est un travailleur configuré qui motive des demandes, sélectionne des outils, exécute des étapes, évalue des résultats et produit des réponses basées sur le contexte de la base de données.

Un agent encapsule le comportement, les politiques et les outils disponibles pour un travail particulier, tels que le traitement des retours ou l'extraction des connaissances.
Équipe de l'agent

Un ou plusieurs agents qui effectuent un flux de travail agentique. Une équipe coordonne les responsabilités, partage le contexte et exécute des paires agent-tâche pour effectuer des interactions en plusieurs étapes de manière fiable.

Les équipes répartissent le travail entre les agents spécialisés et ordonnent leurs contributions. Les équipes gardent un contexte partagé et produisent une réponse unifiée.

Vous pouvez voir les détails de l'exécution de l'agent et de l'équipe à l'aide des vues d'historique suivantes : USER_AI_AGENT_TEAM_HISTORY, USER_AI_AGENT_TASK_HISTORY et USER_AI_AGENT_TOOL_HISTORY. Ces vues enregistrent les invites, les réponses et les exécutions d'outils pour chaque agent, tâche et équipe, offrant transparence et traçabilité dans les flux de travail agéntiques. Pour plus d'informations sur ces vues d'historique, voir DBMS_CLOUD_AI_AGENT Vues d'historique.

Serveur MCP

Un serveur MCP (Model Context Protocol Server) fournit un moyen standardisé pour les applications d'interagir avec des modèles et des outils d'IA générative en exposant les capacités du modèle, l'extraction de contexte et les extensions au moyen d'un protocole cohérent.

À l'aide de Select AI Agent, vous pouvez définir des outils qui peuvent être exposés au moyen du serveur MCP Autonomous AI Database. Ces outils peuvent inclure des outils intégrés pour la génération SQL, la RAG, les notifications (courriel et Slack) et la recherche sur le Web, ainsi que des outils personnalisés. Les outils personnalisés peuvent exposer les fonctions définies dans votre base de données.
Observation

Les données retournées par une exécution d'outil (enregistrements, messages ou erreurs) que l'agent enregistre et évalue au cours de la réflexion. Les observations guident la prochaine étape du raisonnement et fournissent des preuves de la réponse finale.
Tâche

Une tâche représente une unité de travail. Il guide la sélection d'outils, le mappage de paramètres et la politique d'exécution, produisant des résultats que les étapes en aval peuvent lire et résumer.

Les tâches indiquent l'objectif, les entrées, les choix d'outils et les garde-corps. Ils retournent des sorties structurées que les étapes ultérieures peuvent consommer.

Vous pouvez interroger la vue USER_AI_AGENT_TASK_HISTORY pour vérifier comment les tâches sont définies, exécutées et terminées dans une exécution agentique. Pour plus d'informations, voir DBMS_CLOUD_AI_AGENT Vues d'historique.

Outil

Un outil effectue une action telle que la mise à jour des données, l'extraction de documents ou l'appel de services externes. Les outils prennent des paramètres, peuvent exécuter de manière déterministe ou non déterministe et retournent des observations pour raisonnement.

Les outils encapsulent les opérations reproductibles. Ils gardent les effets secondaires contrôlés et observables, soutenant l'audit et le débogage.

Dans la structure Select AI Agent, les outils représentent des blocs fonctionnels que les agents peuvent utiliser lors du traitement des tâches. Un outil peut être :
  • Outil déterministe, tel qu'une fonction PL/SQL, qui renvoie la même sortie pour la même entrée.
  • Outil non déterministe, comme une recherche Web ou une récapitulation basée sur le LLM, où les sorties peuvent varier en fonction du moment, des résultats de réseau ou du hasard.

Les agents sélectionnent des outils en fonction des besoins de la tâche et utilisent la sortie (appelée observation) pour raisonner, décider des étapes suivantes ou générer des réponses. Les métadonnées d'outil et l'historique d'exécution sont consignés pour prendre en charge le débogage, l'observabilité et la sécurité.

Vous pouvez interroger la vue USER_AI_AGENT_TOOL_HISTORY pour surveiller l'utilisation de l'outil et vérifier les résultats d'exécution pour chaque tâche d'agent. Pour plus d'informations, voir Vues de l'historique DBMS_CLOUD_AI_AGENT.

Sélectionner des cas d'utilisation d'agent d'intelligence artificielle

Select AI Agent prend en charge des scénarios pratiques entre les rôles : connecter des services externes, créer une automatisation axée sur les tâches à l'aide d'outils PL/SQL et permettre un accès conversationnel aux données à l'aide d'interactions en langage naturel.

Les cas d'utilisation sont les suivants :

Intégrez des API externes pour des réponses enrichies :

Connecter des services REST tels que le statut d'expédition, les articles de connaissance ou la messagerie. L'agent combine les résultats externes avec les faits de la base de données et retourne des conseils pratiques en temps opportun.

Créez des agents propres à une tâche à l'aide des outils PL/SQL :

Créez des agents ciblés qui appellent des outils PL/SQL pour les mises à jour, les validations ou les transformations, en gardant la logique proche des données, en améliorant le rendement et en simplifiant la maintenance dans les environnements de manière cohérente. Encapsulez le code PL/SQL existant pour les mises à jour et les vérifications. Les agents coordonnent les tâches, appliquent des paramètres et enregistrent les résultats tout en respectant les contrôles transactionnels.

Offrez un accès conversationnel aux données d'entreprise :

Exposez les données au moyen de questions en langage naturel fondées sur des objets de base de données. Utilisez NL2SQL pour extraire, appliquer des politiques et présenter clairement les résultats tout en respectant les exigences de sécurité et de gouvernance. NL2SQL traduit les questions en SQL sur les objets approuvés. Les agents récapitulent les résultats et les étapes suivantes tout en suivant les listes d'objets et les règles d'accès.

Préalables à l'utilisation de Select AI Agent

Avant d'utiliser Select AI Agent, vous devez disposer de privilèges pour utiliser l'ensemble DBMS_CLOUD_AI_AGENT et tous les autres privilèges requis pour Select AI.

Pour utiliser Select AI Agent, vous devez effectuer les opérations suivantes :

Accorder des privilèges pour sélectionner un agent d'intelligence artificielle

Pour configurer DBMS_CLOUD_AI_AGENT :

Accordez le privilège EXECUTE sur l'ensemble DBMS_CLOUD_AI_AGENT à l'utilisateur qui souhaite utiliser Sélectionner un agent d'intelligence artificielle.

Par défaut, seul l'administrateur de système dispose du privilège EXECUTE. L'administrateur peut accorder le privilège EXECUTE à d'autres utilisateurs.

Exemple de privilèges pour exécuter Sélectionner un agent d'intelligence artificielle

L'exemple suivant accorde le privilège EXECUTE à ADB_USER : 

GRANT EXECUTE on DBMS_CLOUD_AI_AGENT to ADB_USER;

Marche à suivre pour utiliser Select AI Agent

Vous pouvez utiliser Sélectionner un agent d'intelligence artificielle à l'aide de l'action agent ou de la fonction DBMS_CLOUD_AI_AGENT.RUN_TEAM.

Vous pouvez utiliser Select AI Agent des façons suivantes :

  • Utilisez agent comme action Sélectionner l'intelligence artificielle : Select AI agent <prompt>.

  • Appelez DBMS_CLOUD_AI_AGENT.RUN_TEAM et fournissez une invite dans la fonction avec d'autres paramètres.

Les deux options acheminent l'invite à l'équipe d'agent choisie et renvoient la réponse de l'équipe.

Voir aussi :

pour en savoir plus.

Exemples d'utilisation de Select AI Agent

Explorez des exemples qui montrent comment créer, configurer et interagir avec Select AI Agent pour des tâches courantes telles que l'analyse de films, l'analyse de journaux et le soutien à la clientèle.

Exemple : Créer un agent

Créez un agent pour effectuer une tâche définie.

Cet exemple crée un agent nommé Customer_Return_Agent responsable du traitement des conversations relatives au retour de produit.

Cet exemple illustre l'utilisation de Google en tant que fournisseur d'IA tel que spécifié dans le profil d'IA nommé GOOGLE. Le profil d'IA identifie le LLM utilisé par l'agent pour le raisonnement et les réponses. L'attribut role fournit des instructions pour guider l'agent. 

BEGIN
  DBMS_CLOUD_AI_AGENT.CREATE_AGENT(
    agent_name => 'CustomerAgent',
    attributes =>'{
       "profile_name": "GOOGLE",
                       "role": "You are an experienced customer agent who deals with customers return request."
     }'
  );
END;
/

Exemple : Créer des outils intégrés

Créez des outils intégrés tels que SQL, RAG, Websearch, Email et Slack. Ces outils permettent aux agents et aux tâches d'interroger des données, d'extraire des connaissances, de rechercher sur le Web et d'envoyer des avis.

Les outils intégrés (par exemple, SQL et RAG) comprennent des instructions internes. Vous pouvez éventuellement ajouter des instructions fournies par l'utilisateur pour adapter le comportement à votre cas d'utilisation. L'ajout d'une instruction peut ajouter un contexte propre à une tâche (par exemple, des interrogations de portée à un schéma spécifique ou aider à appliquer un format de réponse). Cela peut améliorer la pertinence pour les scénarios spécialisés. Des instructions mal écrites ou trop prescriptives peuvent dégrader les performances de l'outil. Gardez les instructions courtes, spécifiques et cohérentes avec l'objectif de l'outil.

Exemple : Outil SQL

Cet exemple crée un outil SQL qui traduit les interrogations en langage naturel en énoncés SQL. L'outil SQL aide les agents à répondre aux questions relatives aux données en mappant les invites aux interrogations SQL.

Cet exemple montre comment utiliser OCI comme fournisseur d'intelligence artificielle, tel que spécifié dans le profil d'intelligence artificielle nommé nl2sql_profile. Le profil d'IA identifie le LLM utilisé par l'agent pour le raisonnement et les réponses. Dans cet exemple, le profil d'intelligence artificielle nl2sql_profile définit le jeu de tables de schéma SH que l'agent peut interroger, ce qui permet un accès en langage naturel aux données d'historique des ventes couramment utilisées, telles que les clients, les produits, les promotions et les pays. L'outil SQL utilise les objets de base de données spécifiés dans le profil d'intelligence artificielle, garantissant que les instructions SQL générées restent exactes et pertinentes pour le jeu de données SH. 

BEGIN
  DBMS_CLOUD_AI.CREATE_PROFILE(
      profile_name => 'nl2sql_profile',
      attributes   => '{"provider": "oci",
        "credential_name": "GEN1_CRED",
        "oci_compartment_id": "ocid1.compartment.oc1..aaaa...",
	object_list": [{"owner": "SH", "name": "customers"},                
                      {"owner": "SH", "name": "countries"},                
                      {"owner": "SH", "name": "supplementary_demographics"},
                      {"owner": "SH", "name": "profits"},                  
                      {"owner": "SH", "name": "promotions"},               
                      {"owner": "SH", "name": "products"}]

       }');
end;
/

EXEC DBMS_CLOUD_AI_AGENT.DROP_TOOL('SQL');
BEGIN
  DBMS_CLOUD_AI_AGENT.CREATE_TOOL(
    tool_name  => 'SQL',
    attributes => '{"tool_type": "SQL",
                    "tool_params": {"profile_name": "nl2sql_profile"}}'
  );
END;
/
Exemple : Outil RAG

Cet exemple crée un outil RAG (Retrieval Augmented Generation). L'outil RAG permet aux agents d'extraire et de baser les réponses dans les documents d'entreprise, améliorant ainsi la précision des réponses basées sur les connaissances.

Cet exemple illustre la définition d'un RAG_PROFILE avec des données d'identification, un index vectoriel et la spécification de paramètres de profil. Puis, en créant un index vectoriel RAG_INDEX dans le stockage d'objets pour les intégrations de document et en créant le RAG_TOOL lié à votre profil. 

BEGIN
  DBMS_CLOUD_AI.CREATE_PROFILE(
          profile_name =>'RAG_PROFILE',
          attributes   =>'{"provider": "oci",
            "credential_name": "GENAI_CRED",
            "vector_index_name": "RAG_INDEX",
            "oci_compartment_id": "ocid1.compartment.oc1..aaaa..",   
            "temperature": 0.2,
            "max_tokens": 3000
          }');
END;
/

BEGIN
   DBMS_CLOUD_AI.CREATE_VECTOR_INDEX(
           index_name  => 'RAG_INDEX',
           attributes  => '{"vector_db_provider": "oracle",
                            "location": "https://swiftobjectstorage.us-phoenix-1.oraclecloud.com/v1/my_namespace/my_bucket/my_data_folder",
                            "object_storage_credential_name": "OCI_CRED",
                            "profile_name": "RAG_PROFILE",
                            "chunk_overlap":128,
                            "chunk_size":1024
   }');
END;
/

EXEC DBMS_CLOUD_AI_AGENT.DROP_TOOL('RAG_TOOL');
BEGIN
  DBMS_CLOUD_AI_AGENT.CREATE_TOOL(
    tool_name  => 'RAG_TOOL',
    attributes => '{"tool_type": "RAG",
                      "tool_params": {"profile_name": "RAG_PROFILE"}}'
  );
END;
/
Exemple : Outil de recherche Web

Cet exemple crée un outil de recherche Web pour extraire des détails à partir d'Internet. L'outil Websearch permet aux agents de rechercher des informations sur le Web, telles que les prix ou les descriptions des produits.

Cet exemple illustre l'ajout d'une entrée de liste de contrôle d'accès pour le fournisseur OpenAI. Création des données d'identification OPENAI_CRED avec votre clé d'API et création de l'outil Websearch, décrivant son objectif, le liant aux données d'identification.

Note :

OpenAI est le seul fournisseur d'intelligence artificielle pour Websearch pris en charge. 
BEGIN
  DBMS_NETWORK_ACL_ADMIN.APPEND_HOST_ACE(
    host => 'api.openai.com',
    ace  => xs$ace_type(privilege_list => xs$name_list('http'),
                        principal_name => 'ADB_USER',
                        principal_type => xs_acl.ptype_db)
   );
END;
/

BEGIN
  DBMS_CLOUD.CREATE_CREDENTIAL(
    credential_name => 'OPENAI_CRED',
    username        => 'OPENAI',
    password        => '<OPENAI_API_KEY>'
  );
END;
/

EXEC DBMS_CLOUD_AI_AGENT.DROP_TOOL('Websearch');
BEGIN
  DBMS_CLOUD_AI_AGENT.create_tool(
    tool_name  => 'Websearch',
    attributes => '{"instruction": "This tool can be used for searching the details about topics mentioned in notes and prepare a summary about prices, details on web",
                      "tool_type": "WEBSEARCH",
                      "tool_params": {"credential_name": "OPENAI_CRED"}}'
  );
END;
/
Exemple : Outil d'avis avec type de courriel

Cet exemple crée un outil d'avis par courriel. L'outil de courriel permet aux agents d'envoyer des courriels d'avis dans le cadre de leur flux des travaux.

Cet exemple illustre la création des données d'identification EMAIL_CRED avec votre mot de passe, l'autorisation de l'accès SMTP pour l'utilisateur de base de données et la création d'un outil d'avis de type EMAIL, notamment les détails SMTP, l'expéditeur et les adresses de destinataire. 

BEGIN
  DBMS_CLOUD.CREATE_CREDENTIAL(
    credential_name => 'EMAIL_CRED',
    username => '<username>',
    password => '<password>');
END;
/
-- Allow SMTP access for user
BEGIN
   DBMS_NETWORK_ACL_ADMIN.APPEND_HOST_ACE(
     host => 'smtp.email.us-ashburn-1.oci.oraclecloud.com',
     lower_port => 587,
     upper_port => 587,
     ace => xs$ace_type(privilege_list => xs$name_list('SMTP'),
                        principal_name => 'ADB_USER',
                        principal_type => xs_acl.ptype_db));
END;
/

EXEC DBMS_CLOUD_AI_AGENT.DROP_TOOL('Email');
BEGIN
  DBMS_CLOUD_AI_AGENT.CREATE_TOOL(
    tool_name  => 'EMAIL',
    attributes => '{"tool_type": "NOTIFICATION",
                    "tool_params": {"notification_type" : "EMAIL",
                                    "credential_name": "EMAIL_CRED",
                                    "recipient": "example_recipient@oracle.com",
                                    "smtp_host": "smtp.email.us-ashburn-1.oci.oraclecloud.com",
                                    "sender": "example_sender@oracle.com"}}'
  );
END;
/
Exemple : Outil de notification avec type Slack

Cet exemple crée un outil de notification Slack. L'outil Slack permet aux agents de transmettre des notifications directement à un canal d'espace de travail Slack.

Cet exemple illustre l'ajout d'une entrée de liste de contrôle d'accès pour Slack et la création d'un outil d'avis de type SLACK le liant à SLACK_CRED et au canal cible. 

BEGIN
 DBMS_NETWORK_ACL_ADMIN.APPEND_HOST_ACE (
  host         => 'slack.com',
  lower_port   => 443,
  upper_port   => 443,
  ace          => xs$ace_type(
      privilege_list => xs$name_list('http'),
      principal_name => 'ADB_USER',
      principal_type => xs_acl.ptype_db));
END;
/
 
BEGIN
  DBMS_CLOUD_AI_AGENT.create_tool(
    tool_name  => 'slack',
    attributes => '{"tool_type": "SLACK",
                    "tool_params": {"credential_name": "SLACK_CRED",
                                    "channel": "<channel_number>"}}'
  );
END;
/

Exemple : Créer une tâche

Créer une tâche qu'un agent peut effectuer.

Note :

Seul un administrateur de base de données peut accorder des privilèges EXECUTE et une procédure de liste de contrôle d'accès réseau.

Exemple : Créer une tâche de courriel

Cet exemple crée Generate_Email_Task qui indique au LLM de produire un courriel de confirmation standard à l'aide de données structurées.

L'exemple suivant illustre l'utilisation de l'attribut instruction et fournit des instructions sur ce que le courriel doit inclure. 

BEGIN DBMS_CLOUD_AI_AGENT.DROP_TASK('Generate_Email_Task');
EXCEPTION WHEN OTHERS THEN NULL; END;
/
BEGIN
    DBMS_CLOUD_AI_AGENT.CREATE_TASK(
    task_name => 'Generate_Email_Task',
    attributes => '{"instruction": "Use the customer information and product details to generate an email in a professional format. The email should:' || 
                    '1. Include a greeting to the customer by name' || 
                    '2. Specify the item being returned, the order number, and the reason for the return' ||
                    '3. If it is a refund, state the refund will be issued to the credit card on record.' ||
                    '4. If it is a replacement, state that the replacement will be shipped in 3-5 business days."}'
    );
END;
Exemple : Créer une tâche d'extraction de journal

Cet exemple crée un fichier FETCH_LOGS_TASK qui extrait les journaux en fonction de la demande.

Cet exemple illustre la création d'une tâche qui utilise l'outil log_fetcher pour extraire les journaux. Cet outil personnalisé spécifie la procédure PL/SQL fetch_logs. L'instruction de tâche indique ce que la tâche doit accomplir. L'attribut enable_human_tool est réglé à Vrai afin qu'une personne puisse intervenir pour guider ou approuver le flux de tâches, si nécessaire. Voir pour un exemple complet. 

BEGIN
  DBMS_CLOUD_AI_AGENT.CREATE_TASK(
    task_name  =>'FETCH_LOGS_TASK',
    attributes =>'{
       "instruction": "Fetch the log entries from the database based on user request: {query}",
       "tools": ["log_fetcher"],
       "enable_human_tool" : "true"
     }'
  );
END;
/
Exemple : Créer une tâche d'analyse de journal

Cet exemple crée un fichier ANALYZE_LOG_TASK qui analyse les journaux extraits.

L'exemple suivant illustre l'utilisation de FETCH_LOGS_TASK comme attribut input. La tâche nommée ANALYZE_LOG_TASK commence après la collecte des journaux pour avoir une sortie FETCH_LOGS_TASK en entrée. L'instruction de tâche indique ce que la tâche doit accomplir. L'attribut enable_human_tool est réglé à Faux, ce qui indique l'absence de révision en boucle. 

BEGIN
    DBMS_CLOUD_AI_AGENT.CREATE_TASK(
      task_name  =>'ANALYZE_LOG_TASK',
      attributes =>'{"instruction": "Analyze the fetched log entries retrieved based on user request: {query} ' ||
                      'Generate a detailed report include issue analysis and possible solution.",
         "input" : "FETCH_LOGS_TASK",
         "enable_human_tool" : "false"
       }'
    );
END;
/

Exemple : Créer une équipe d'agent

Créez des équipes d'agents pour accomplir vos tâches.

Exemple : Créer une équipe d'agent

Cet exemple crée l'équipe ReturnAgency et inclut un agent unique Customer_Return_Agent. La tâche Return_And_Price_Match est affectée à l'agent. Cette tâche gère les demandes de retour en demandant le motif et en mettant à jour le statut de la commande dans votre base de données. process est réglé à sequential pour exécuter les tâches dans un ordre défini. 

BEGIN                                                                
  DBMS_CLOUD_AI_AGENT.CREATE_TEAM( 
    team_name  => 'ReturnAgency',                                                            
    attributes => '{"agents": [{"name":"Customer_Return_Agent","task" : "Return_And_Price_Match"}],
                    "process": "sequential"}');                                                                
END;                                                                      
/

Voir pour un exemple complet.

Exemple : Créer une équipe multiagent

Cet exemple crée l'équipe Ops_Issues_Solution_Team et inclut deux agents pour gérer l'analyse et le dépannage des journaux : Data_Engineer et Ops_Manager. L'agent Data_Engineer exécute la tâche fetch_logs_task et l'agent Ops_Manager exécute la tâche analyze_log_task. process est réglé à sequential pour exécuter les tâches dans un ordre défini. 

BEGIN
      DBMS_CLOUD_AI_AGENT.create_team(
        team_name  => 'Ops_Issues_Solution_Team',
        attributes => '{"agents": [{"name":"Data_Engineer","task" : "fetch_logs_task"},
                                   {"name":"Ops_Manager","task" : "analyze_log_task"}],
                "process": "sequential"
                }');
END;
/

Voir pour un exemple complet.

Exemple : Créer un agent d'analyse de film à l'aide d'outils intégrés

Cet exemple montre comment créer un agent d'analyse de film à l'aide de l'option Sélectionner un agent d'intelligence artificielle. Dans cet exemple, vous configurez un agent d'analyse de film qui extrait les données, répond aux questions, effectue des recherches sur le Web et envoie l'analyse par courriel ou envoie des avis Slack.

L'exemple suivant suppose que les données sont à votre disposition.

Cet exemple crée un agent MOVIE_ANALYST et utilise plusieurs outils intégrés tels que SQL, RAG, WEBSEARCH et l'outil NOTIFICATION de type : EMAIL et SLACK. L'agent répond aux questions liées aux films à l'aide d'invites en langage naturel.

Dans cet exemple, après que votre administrateur de base de données a accordé des privilèges EXECUTE pour : les ensembles DBMS_CLOUD_AI_AGENT, DBMS_CLOUD_AI, DBMS_CLOUD_PIPELINE, l'accès à la liste de contrôle d'accès pour votre fournisseur d'intelligence artificielle, l'accès SMTP et l'accès Slack, vous commencez par créer l'agent MOVIE_ANALYST.

Créer un agent

Vous créez un agent nommé MOVIE_ANALYST avec un profil (GROK) et le rôle de répondre aux questions sur les films, les acteurs et les genres.

Créer une tâche

Vous créez une tâche nommée ANALYZE_MOVIE_TASK avec des instructions pour répondre aux interrogations liées aux films.

Créer l'équipe

Vous créez une équipe MOVIE_AGENT_TEAM avec MOVIE_ANALYST comme agent et la tâche ANALYZE_MOVIE_TASK et la définissez comme équipe active.

Vous pouvez ensuite attacher des outils tels que SQL, RAG, Websearch ou Notification pour étendre ses fonctionnalités.

Exécuter l'équipe Select AI Agent

Vous exécutez maintenant l'équipe de l'agent en utilisant select ai agent comme préfixe pour vos invites.

Créer des outils

Vous associez ensuite différents outils d'agent intégrés :
  • SQL : Utilise un profil NL2SQL pour traduire les questions en interrogations SQL et autres actions Sélectionner l'IA prises en charge.
  • RAG : Extraire le contexte basé sur les connaissances à partir des documents stockés.
  • WEBSEARCH : Rassemblez les détails du film ou les prix en ligne.
  • NOTIFICATION:
    • EMAIL : Envoyer des réponses aux invites d'utilisateur, aux rapports de film ou aux évaluations à un destinataire.
    • SLACK : Envoyer des réponses aux invites d'utilisateur, aux sommaires ou aux mises à jour directement à Slack.

L'exemple complet est le suivant :

--Grants EXECUTE privilege to ADB_USER
--
GRANT EXECUTE on DBMS_CLOUD_AI_AGENT to ADB_USER;
GRANT EXECUTE on DBMS_CLOUD_AI to ADB_USER;
GRANT EXECUTE on DBMS_CLOUD_PIPELINE to ADB_USER;

-- Websearch tool accesses OPENAI endpoint, allow ACL access
BEGIN
  DBMS_NETWORK_ACL_ADMIN.APPEND_HOST_ACE(
    host => 'api.openai.com',
    ace  => xs$ace_type(privilege_list => xs$name_list('http'),
                        principal_name => 'ADB_USER',
                        principal_type => xs_acl.ptype_db)
   );
END;
/

-- To allow Email tool in Autonomous Database, allow SMTP access

BEGIN
   DBMS_NETWORK_ACL_ADMIN.APPEND_HOST_ACE(
     host => 'smtp.email.us-ashburn-1.oci.oraclecloud.com',
     lower_port => 587,
     upper_port => 587,
     ace => xs$ace_type(privilege_list => xs$name_list('SMTP'),
                        principal_name => 'ADB_USER,
                        principal_type => xs_acl.ptype_db));
END;
/

-- Allow ACL access to Slack

BEGIN
 DBMS_NETWORK_ACL_ADMIN.APPEND_HOST_ACE (
  host         => 'slack.com',
  lower_port   => 443,
  upper_port   => 443,
  ace          => xs$ace_type(
      privilege_list => xs$name_list('http'),
      principal_name => 'ADB_USER',
      principal_type => xs_acl.ptype_db));
END;
/

PL/SQL procedure successfully completed.

--Create an agent
BEGIN
   DBMS_CLOUD_AI_AGENT.CREATE_AGENT(
     agent_name => 'MOVIE_ANALYST',
     attributes => '{"profile_name": "GROK",
                     "role": "You are an AI Movie Analyst. Your can help answer a variety of questions related to movies. "
             }'
   );
END;
/

PL/SQL procedure successfully completed.

BEGIN
    DBMS_CLOUD_AI_AGENT.CREATE_TASK(
      task_name  => 'ANALYZE_MOVIE_TASK',
      attributes => '{"instruction": "Help the user with their request about movies. User question: {query}",
         "enable_human_tool" : "true"
       }'
    );
END;
/

PL/SQL procedure successfully completed.

BEGIN                                                                 
  DBMS_CLOUD_AI_AGENT.CREATE_TEAM(  
    team_name  => 'MOVIE_AGENT_TEAM',                                                            
    attributes => '{"agents": [{"name":"MOVIE_ANALYST","task" : "ANALYZE_MOVIE_TASK"}],
                    "process": "sequential"
                    }');                                                                 
END;                                                                        
/

PL/SQL procedure successfully completed.

EXEC DBMS_CLOUD_AI_AGENT.SET_TEAM('MOVIE_AGENT_TEAM');

PL/SQL procedure successfully completed.

select ai agent who are you?;

RESPONSE
--------------------------------------------------------------------------------
I'm MOVIE_ANALYST, an AI Movie Analyst here to assist with any questions or topi
cs related to movies. Whether you need information on films, actors, directors,
genres, or recommendations, I'm ready to help. What can I assist you with regard
ing movies?

-- SQL TOOL
BEGIN   
  DBMS_CLOUD_AI.CREATE_PROFILE(  
    profile_name =>'nl2sql_profile',                                                            
    attributes => '{"provider": "oci",                                                                  
      "credential_name": "GENAI_CRED",
      "oci_compartment_id" : "ocid1.compartment.oc1..aaaaa...",                               
      "object_list": [{"owner": "ADB_USER", "name": "GENRE"},
                      {"owner": "ADB_USER", "name": "CUSTOMER"},
                      {"owner": "ADB_USER", "name": "WATCH_HISTORY"},
                      {"owner": "ADB_USER", "name": "STREAMS"},
                      {"owner": "ADB_USER", "name": "MOVIES"},
                      {"owner": "ADB_USER", "name": "ACTORS"}]
      }');                                                                 
END;                                                                        
/

PL/SQL procedure successfully completed.

BEGIN
  DBMS_CLOUD_AI_AGENT.CREATE_TOOL(
    tool_name  => 'SQL',
    attributes => '{"tool_type": "SQL",
                    "tool_params": {"profile_name": "nl2sql_profile"}}'
  );
END;
/

PL/SQL procedure successfully completed.

EXEC DBMS_CLOUD_AI_AGENT.drop_task('ANALYZE_MOVIE_TASK');

PL/SQL procedure successfully completed.

BEGIN
    DBMS_CLOUD_AI_AGENT.CREATE_TASK(
      task_name => 'ANALYZE_MOVIE_TASK',
      attributes =>'{"instruction": "Help the user with their request about movies. User question: {query}. ' ||
                       'You can use SQL tool to search the data from database",
        "tools": ["SQL"],
         "enable_human_tool" : "true"
       }'
    );
END;
/

PL/SQL procedure successfully completed.

EXEC DBMS_CLOUD_AI_AGENT.CLEAR_TEAM;

PL/SQL procedure successfully completed.

EXEC DBMS_CLOUD_AI_AGENT.SET_TEAM('MOVIE_AGENT_TEAM');

PL/SQL procedure successfully completed.

-- SQL tool retrieves the movie with the highest popularity view count from the watch_history table
select ai agent what is the most popular movie?;

RESPONSE
----------------------------------------------------------------
The most popular movie is "Laugh Out Loud" released in 2008.

-- RAG TOOL
BEGIN
  DBMS_CLOUD_AI.CREATE_PROFILE(
         profile_name => 'RAG_PROFILE',
         attributes =>'{"provider": "oci",
            "credential_name": "GENAI_CRED",
            "vector_index_name": "RAG_INDEX",
            "oci_compartment_id": "ocid1.compartment.oc1..aaaaa...",   
            "temperature": 0.2,
            "max_tokens": 3000
          }');
END;
/

PL/SQL procedure successfully completed.

BEGIN
   DBMS_CLOUD_AI.CREATE_VECTOR_INDEX(
           index_name  => 'RAG_INDEX',
           attributes  => '{"vector_db_provider": "oracle",
                            "location": "https://swiftobjectstorage.us-phoenix-1.oraclecloud.com/v1/my_namespace/my_bucket/my_data_folder",
                            "object_storage_credential_name": "MY_OCI_CRED",
                            "profile_name": "RAG_PROFILE",
                            "vector_dimension": 1024,
                            "vector_distance_metric": "cosine",
                            "chunk_overlap":128,
                            "chunk_size":1024
   }');
END;
/
PL/SQL procedure successfully completed.

BEGIN
  DBMS_CLOUD_AI_AGENT.CREATE_TOOL(
    tool_name  => 'RAG_TOOL',
    attributes => '{"tool_type": "RAG",
                      "tool_params": {"profile_name": "RAG_PROFILE"}}'
  );
END;
/

PL/SQL procedure successfully completed.

BEGIN
    DBMS_CLOUD_AI_AGENT.CREATE_TASK(
      task_name =>'ANALYZE_MOVIE_TASK',
      attributes => '{"instruction": "Help the user with their request about movies. User question: {query}. ' ||
                       'You can use RAG tool to search the information from the knowledge base user give.",
        "tools": ["RAG_TOOL"],
         "enable_human_tool" : "true"
       }'
    );
END;
/

PL/SQL procedure successfully completed.

EXEC DBMS_CLOUD_AI_AGENT.CLEAR_TEAM;

PL/SQL procedure successfully completed.

EXEC DBMS_CLOUD_AI_AGENT.SET_TEAM('MOVIE_AGENT_TEAM');

PL/SQL procedure successfully completed.

-- Rag seach the object store to find review or comments of Movie Laugh out Loud 
select ai agent Please find the comments of Movie Laugh out Loud;

RESPONSE
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
The comments for the movie "Laugh Out Loud" (2008) are as follows:
1. A lighthearted comedy that delivers plenty of laughs, though the plot is fairly predictable.
2. The performances are fun, especially from the lead actor who keeps the energy high.
3. Some jokes feel a bit outdated, but overall it is an enjoyable watch for a casual movie night.
4. Good chemistry between the cast members, which makes the humor more natural.
5. Not a groundbreaking comedy, but it does what it promises makes you laugh out loud.

-- WEBSEARCH TOOL
BEGIN
  DBMS_CLOUD.CREATE_CREDENTIAL(
    credential_name => 'OPENAI_CRED',
    username        => 'OPENAI',
    password        => '<API_KEY>'
  );
END;
/

PL/SQL procedure successfully completed.

BEGIN
  DBMS_CLOUD_AI_AGENT.CREATE_TOOL(
    tool_name  => 'WEBSEARCH_TOOL',
    attributes => '{"instruction": "This tool can be used for searching the details about topics mentioned in notes and prepare a summary about prices, details on web",
                      "tool_type": "WEBSEARCH",
                      "tool_params": {"credential_name": "OPENAI_CRED"}}'
  );
END;
/

PL/SQL procedure successfully completed.

BEGIN
    DBMS_CLOUD_AI_AGENT.CREATE_TASK(
      task_name => 'ANALYZE_MOVIE_TASK',
      attributes => '{"instruction": "Help the user with their request about movies. User question: {query}. ' ||
                       'You can use WEBSEARCH_TOOL tool to search the information from internet.",
        "tools": ["WEBSEARCH_TOOL"],
         "enable_human_tool" : "true"
       }'
    );
END;
/

PL/SQL procedure successfully completed.

EXEC DBMS_CLOUD_AI_AGENT.CLEAR_TEAM;

PL/SQL procedure successfully completed.

EXEC DBMS_CLOUD_AI_AGENT.SET_TEAM('MOVIE_AGENT_TEAM');

PL/SQL procedure successfully completed.

select ai agent What is the most popular movie of 2023?;

RESPONSE
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Determining the most popular movie of 2023 can depend on various metrics such as box office earnings, streaming viewership, critical acclaim, or audience reception. Based on global box office data, which is often a strong indicator of popularity, the most successful movie of 2023 is "Barbie," directed by Greta Gerwig. Released in July 2023, it grossed over $1.4 billion worldwide, making it the highest-grossing film of the year and one of the biggest cultural phenomena, often discussed alongside "Oppenheimer" due to the "Barbenheimer" trend. Its widespread appeal, marketing, and social media buzz further solidify its status as the most popular movie of 2023. However, if you are looking for popularity based on a different metric (like streaming numbers or awards), please let me know, and I can adjust the analysis accordingly.

-- NOTIFICATION TOOL WITH EMAIL TYPE

BEGIN
  DBMS_CLOUD_AI_AGENT.CREATE_TOOL(
    tool_name  => 'EMAIL',
    attributes => q'[{"tool_type": "Notification",
                      "tool_params": {"notification_type" : "EMAIL",
                                      "credential_name": "EMAIL_CRED",
                                      "recipient": "example@oracle.com",
                                      "smtp_host": "smtp.email.us-ashburn-1.oci.oraclecloud.com",
                                      "sender": "example@oracle.com"}}]'
  );
END;
/

PL/SQL procedure successfully completed.

BEGIN
    DBMS_CLOUD_AI_AGENT.CREATE_TASK(
      task_name => 'ANALYZE_MOVIE_TASK',
      attributes =>'{"instruction": "Help the user with their request about movies. User question: {query}. ' ||
                       'You can use EMAIL TOOL tool to send email to the user.",
        "tools": ["EMAIL"],
         "enable_human_tool" : "true"
       }'
    );
END;
/

PL/SQL procedure successfully completed.

EXEC DBMS_CLOUD_AI_AGENT.CLEAR_TEAM;

PL/SQL procedure successfully completed.

EXEC DBMS_CLOUD_AI_AGENT.SET_TEAM('MOVIE_AGENT_TEAM');

PL/SQL procedure successfully completed.

select ai agent Please help me write a review of Movie "Barbie" and send the review to my email;

RESPONSE
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
I have written a review for the movie "Barbie" (2023) and sent it to your email. Please check your inbox for the detailed review. If you have any additional feedback or would like me to revise the review, let me know!

-- NOTIFICATION TOOL WITH SLACK TYPE

DBMS_CLOUD_AI_AGENT.CREATE_TOOL(
    tool_name  => 'SLACK_TOOL',
    attributes => '{"tool_type": "SLACK",
                    "tool_params": {"credential_name": "SLACK_CRED",
                                    "channel": "<channel_number>"}}'
  );
END;
/

PL/SQL procedure successfully completed.

BEGIN
    DBMS_CLOUD_AI_AGENT.CREATE_TASK(
      task_name  => 'ANALYZE_MOVIE_TASK',
      attributes => '{"instruction": "Help the user with their request about movies. User question: {query}. ' ||
                       'You can use SLACK TOOL to send the notification to the user.",
        "tools": ["SLACK_TOOL"],
         "enable_human_tool" : "true"
       }'
    );
END;
/

PL/SQL procedure successfully completed.

select ai agent Please help me find the top 3 most-watched movies of 2023 and send them to me on slack;

RESPONSE
------------------------------------------------------------------------------------------------------------------------------------
I have sent the list of the top 3 most-watched movies of 2023 to you via Slack. Please check your Slack notifications for the details.

Exemple : Créer un agent de retour de produit

Cet exemple montre comment créer un agent conversationnel tournant à l'aide de l'option Sélectionner un agent d'intelligence artificielle. Dans cet exemple, vous configurez un agent du service à la clientèle qui traite les retours de produits et met à jour le statut des retours dans votre base de données.

Cet exemple crée un agent nommé Customer_Return_Agent et un outil nommé Update_Order_Status_Tool, puis définit une tâche et une équipe pour gérer le retour de produit.

Dans cet exemple, après que votre administrateur de base de données a accordé des privilèges EXECUTE pour : DBMS_CLOUD_AI_AGENT et DBMS_CLOUD_AI, vous commencez par créer des données-échantillons de clients, le statut de la commande client et une fonction pour mettre à jour le statut de la commande client. Créez ensuite un agent nommé Customer_Return_Agent.

Créer un agent

Vous créez un agent nommé Customer_Return_Agent avec un profil (OCI_GENAI_GROK) et un rôle pour gérer les demandes de retour.

Créer des outils

Vous créez ensuite un outil d'agent nommé Update_Order_Status_Tool pour mettre à jour le statut de la commande dans votre base de données.

Créer une tâche

Vous créez une tâche nommée Handle_Product_Return_Task pour guider le flux : demandez la raison (n'est plus nécessaire, est arrivé trop tard, boîte cassée ou défectueux). Procédez à un flux de retour défectueux.

Créer l'équipe

Vous créez une équipe d'agent nommée Return_Agency_Team avec Customer_Return_Agent comme agent et vous la définissez comme équipe active.

Exécuter l'équipe Select AI Agent

Vous exécutez maintenant l'équipe de l'agent en utilisant select ai agent comme préfixe pour vos invites.

L'exemple complet est le suivant :

--Grants EXECUTE privilege to ADB_USER
--
GRANT EXECUTE on DBMS_CLOUD_AI_AGENT to ADB_USER;
GRANT EXECUTE on DBMS_CLOUD_AI to ADB_USER;

BEGIN
  DBMS_CLOUD_AI_AGENT.CREATE_AGENT(
    agent_name => 'Customer_Return_Agent',
    attributes => '{"profile_name": "OCI_GENAI_GROK",
                    "role": "You are an experienced customer return agent who deals with customers return requests."}');
END;
/
 
PL/SQL procedure successfully completed.
 
  

--Sample customer data
CREATE TABLE CUSTOMERS (
    customer_id  NUMBER(10) PRIMARY KEY,
    name         VARCHAR2(100),
    email        VARCHAR2(100),
    phone        VARCHAR2(20),
    state        VARCHAR2(2),
    zip          VARCHAR2(10)
);

INSERT INTO CUSTOMERS (customer_id, name, email, phone, state, zip) VALUES
(1, 'Alice Thompson', 'alice.thompson@example.com', '555-1234', 'NY', '10001'),
(2, 'Bob Martinez', 'bob.martinez@example.com', '555-2345', 'CA', '94105'),
(3, 'Carol Chen', 'carol.chen@example.com', '555-3456', 'TX', '73301'),
(4, 'David Johnson', 'david.johnson@example.com', '555-4567', 'IL', '60601'),
(5, 'Eva Green', 'eva.green@example.com', '555-5678', 'FL', '33101');

--create customer order status
CREATE TABLE CUSTOMER_ORDER_STATUS (
    customer_id     NUMBER(10),
    order_number    VARCHAR2(20),
    status          VARCHAR2(30),
    product_name    VARCHAR2(100)

);

INSERT INTO CUSTOMER_ORDER_STATUS (customer_id, order_number, status, product_name) VALUES
(2, '7734', 'delivered', 'smartphone charging cord'),
(1, '4381', 'pending_delivery', 'smartphone protective case'),
(2, '7820', 'delivered', 'smartphone charging cord'),
(3, '1293', 'pending_return', 'smartphone stand (metal)'),
(4, '9842', 'returned', 'smartphone backup storage'),
(5, '5019', 'delivered', 'smartphone protective case'),
(2, '6674', 'pending_delivery', 'smartphone charging cord'),
(1, '3087', 'returned', 'smartphone stand (metal)'),
(3, '7635', 'pending_return', 'smartphone backup storage'),
(4, '3928', 'delivered', 'smartphone protective case'),
(5, '8421', 'pending_delivery', 'smartphone charging cord'),
(1, '2204', 'returned', 'smartphone stand (metal)'),
(2, '7031', 'pending_delivery', 'smartphone backup storage'),
(3, '1649', 'delivered', 'smartphone protective case'),
(4, '9732', 'pending_return', 'smartphone charging cord'),
(5, '4550', 'delivered', 'smartphone stand (metal)'),
(1, '6468', 'pending_delivery', 'smartphone backup storage'),
(2, '3910', 'returned', 'smartphone protective case'),
(3, '2187', 'delivered', 'smartphone charging cord'),
(4, '8023', 'pending_return', 'smartphone stand (metal)'),
(5, '5176', 'delivered', 'smartphone backup storage');

--Create a update customer order status function
CREATE OR REPLACE FUNCTION UPDATE_CUSTOMER_ORDER_STATUS (
    p_customer_name IN VARCHAR2,
    p_order_number  IN VARCHAR2,
    p_status        IN VARCHAR2
) RETURN CLOB IS
    v_customer_id  customers.customer_id%TYPE;
    v_row_count    NUMBER;
BEGIN
    -- Find customer_id from customer_name
    SELECT customer_id
    INTO v_customer_id
    FROM customers
    WHERE name = p_customer_name;
    
    UPDATE customer_order_status
    SET status = p_status
    WHERE customer_id = v_customer_id
      AND order_number = p_order_number;

    v_row_count := SQL%ROWCOUNT;

    IF v_row_count = 0 THEN
        RETURN 'No matching record found to update.';
    ELSE
        RETURN 'Update successful.';
    END IF;
EXCEPTION
    WHEN OTHERS THEN
        RETURN 'Error: ' || SQLERRM;
END;

--Create Tool
BEGIN
    DBMS_CLOUD_AI_AGENT.CREATE_TOOL(
        tool_name => 'Update_Order_Status_Tool',
        attributes => '{"instruction": "This tool updates the database to reflect return status change. Always confirm user name and order number with user before update status",
                        "function" : "update_customer_order_status"}',
        description => 'Tool for updating customer order status in database table.'
    );
END;
/
--Create Task
BEGIN
  DBMS_CLOUD_AI_AGENT.CREATE_TASK(
    task_name => 'Handle_Product_Return_Task',
    attributes => '{"instruction": "Process a product return request from a customer:{query}' || 
                    '1. Ask customer the order reason for return (no longer needed, arrived too late, box broken, or defective)' || 
                    '2. If no longer needed:' ||
                    '   a. Inform customer to ship the product at their expense back to us.' ||
                    '   b. Update the order status to return_shipment_pending using Update_Order_Status_Tool.' ||
                     '3. If it arrived too late:' ||
                    '   a. Ask customer if they want a refund.' ||
                    '   b. If the customer wants a refund, then confirm refund processed and update the order status to refund_completed' || 
                    '4. If the product was defective or the box broken:' ||
                    '   a. Ask customer if they want a replacement or a refund' ||
                    '   b. If a replacement, inform customer replacement is on its way and they will receive a return shipping label for the defective product, then update the order status to replaced' ||
                    '   c. If a refund, inform customer to print out the return shipping label for the defective product, return the product, and update the order status to refund' ||
                    '5. After the completion of a return or refund, ask if you can help with anything else.' ||
                    '   End the task if user does not need help on anything else",
                    "tools": ["Update_Order_Status_Tool"]}'
  );
END;
/
SQL> BEGIN                                                                
  DBMS_CLOUD_AI_AGENT.CREATE_TEAM( 
    team_name  => 'Return_Agency_Team',                                                            
    attributes => '{"agents": [{"name":"Customer_Return_Agent","task" : "Handle_Product_Return_Task"}],
                    "process": "sequential"}');                                                                
END;                                                                      
/
 
PL/SQL procedure successfully completed.
 
SQL> EXEC DBMS_CLOUD_AI_AGENT.SET_TEAM('Return_Agency_Team');
 
PL/SQL procedure successfully completed.

--Validate that the agent team is set in the current session with get_team
SQL> SELECT DBMS_CLOUD_AI_AGENT.GET_TEAM from DUAL;
 
--Interact with the agent
SQL> select ai agent I want to return a smartphone case;

RESPONSE
Could you please tell me the reason for returning the smartphone case? Is it no longer needed, arrived too late, box broken, or defective?

SQL> select ai agent the item is defective

RESPONSE
I'm sorry to hear that the smartphone case is defective. Would you like a replacement or a refund?

SQL> select ai agent I will need a replacement

RESPONSE
Can you please confirm your name and order number so I can update the status and process the replacement?

SQL> select ai agent I''m Bob Martinez and my order number is 7820

RESPONSE
Is there anything else I can help you with?

SQL> select ai agent No, I''m all set. Thanks

RESPONSE
Thank you for reaching out, Bob. I'm glad I could assist with the return of your smartphone case and stand. If you have any further questions or need assistance in the future, feel free to contact us. Have a great day!
Exemple : Utiliser Select AI Agent avec Database Actions et APEX

Si vous utilisez des clients SQL Web tels que Database Actions, exécutez l'équipe de l'agent à l'aide de la fonction DBMS_CLOUD_AI_AGENT.RUN_TEAM et fournissez votre invite dans la fonction.

Note :

N'utilisez pas DBMS_CLOUD_AI_AGENT.SET_TEAM dans Database Actions ou le service APEX. Indiquez plutôt l'équipe de l'agent à l'aide de l'argument team_name de DBMS_CLOUD_AI_AGENT.RUN_TEAM.

L'exemple suivant crée un ID conversation pour suivre l'historique de conversation du client, puis utilise la fonction DBMS_CLOUD_AI_AGENT.RUN_TEAM pour interagir avec l'agent de retour de produit.

Pour plus d'informations, voir . 

CREATE OR REPLACE PACKAGE my_globals IS
  l_team_cov_id varchar2(4000);
END my_globals;
/
-- Create conversation
DECLARE
  l_team_cov_id varchar2(4000);
BEGIN
  l_team_cov_id := DBMS_CLOUD_AI.create_conversation();
  my_globals.l_team_cov_id := l_team_cov_id;
  DBMS_OUTPUT.PUT_LINE('Created conversation with ID: ' || my_globals.l_team_cov_id);
END;

--Interact with the agent
DECLARE
  v_response VARCHAR2(4000);
BEGIN
  v_response :=  DBMS_CLOUD_AI_AGENT.RUN_TEAM(
    team_name   => 'Return_Agency_Team',
    user_prompt => 'I want to return a smartphone case',
    params      => '{"conversation_id": "' || my_globals.l_team_cov_id || '"}'
  );
  DBMS_OUTPUT.PUT_LINE(v_response);
END;

Exemple : Extraire et analyser des rapports de journal

Cet exemple montre comment créer une équipe d'agents à l'aide de deux paires agent-tâche pour extraire les journaux et les analyser.

Cet exemple crée :
  • flux de travail à deux agents pour le dépannage : Data_Engineer et Ops_Manager
  • un outil : log-fetcher
puis définit les tâches et l'équipe pour extraire les journaux et les analyser.

Note :

Seul un administrateur de base de données peut exécuter les privilèges EXECUTE et la procédure de liste de contrôle d'accès réseau.

Dans cet exemple, après que votre administrateur de base de données a accordé des privilèges EXECUTE pour : l'ensemble DBMS_CLOUD_AI_AGENT, l'ensemble DBMS_CLOUD_AI et l'accès à la liste de contrôle d'accès pour vos fournisseurs d'intelligence artificielle, vous commencez par créer les agents Data_Engineer et Ops_Manager.

Créer un agent

Vous créez l'agent nommé Data_Engineer avec un profil (GOOGLE) qui utilise Google comme fournisseur et rôle d'IA pour extraire et traiter des données complexes.

Créez l'agent nommé Ops_Manager avec un profil (OPENAI) qui utilise OpenAI comme fournisseur et rôle d'intelligence artificielle pour analyser les données.

Créer un outil

Vous créez ensuite un outil d'agent :log_fetcher : retourne les entrées de journal après une date donnée. Cette opération utilise une procédure personnalisée fetch_logs.

Créer des tâches

Vous définissez deux tâches fetch_logs_task et analyze_log_task pour guider le flux. fetch_logs_task appelle log_fetcher pour extraire les journaux en fonction de la demande. analyze_log_task analyse les journaux extraits.

Créer l'équipe

Vous créez une équipe Ops_Issues_Solution_Team avec Data_Engineer et Ops_Manager pour une exécution séquentielle.

Exécuter la sélection de l'agent d'intelligence artificielle

Vous définissez maintenant l'équipe active et exécutez l'équipe de l'agent avec select ai agent comme préfixe pour vos invites.

L'exemple complet est le suivant :

--Grants EXECUTE privilege to ADB_USER
--
GRANT EXECUTE on DBMS_CLOUD_AI_AGENT to ADB_USER;
GRANT EXECUTE on DBMS_CLOUD_AI to ADB_USER;

-- Grant Network ACL for OpenAI endpoint
BEGIN  
     DBMS_NETWORK_ACL_ADMIN.APPEND_HOST_ACE(
         host => 'api.openai.com',
         ace  => xs$ace_type(privilege_list => xs$name_list('http'),
                             principal_name => 'ADB_USER',
                             principal_type => xs_acl.ptype_db)
     );
END;
/
--Grant Network ACL for Google endpoint
BEGIN
      DBMS_NETWORK_ACL_ADB_USER.APPEND_HOST_ACE(
        host => 'generativelanguage.googleapis.com',
        ace  => xs$ace_type(privilege_list => xs$name_list('http'),
                    principal_name => 'ADB_USER',
                    principal_type => xs_acl.ptype_db)
       );
END;
/
PL/SQL procedure successfully completed.

--Create a table with Database logs and insert sample data

SQL> CREATE TABLE app_logs (
  log_id         NUMBER GENERATED BY DEFAULT AS IDENTITY,
  log_timestamp  DATE,
  log_message    VARCHAR2(4000)
);

Table created.

SQL> INSERT INTO app_logs (log_timestamp, log_message) VALUES (
  TO_DATE('2025-03-22 03:15:45', 'YYYY-MM-DD HH24:MI:SS'),
  'INFO: Database Cluster: Failover completed successfully. Standby promoted to primary. Downtime duration: 33 seconds. Correlation ID: dbfailover102.'
);

1 row created.

SQL> INSERT INTO app_logs (log_timestamp, log_message) VALUES (
  TO_DATE('2025-03-23 08:44:10', 'YYYY-MM-DD HH24:MI:SS'),
  'INFO: Switchover Process: Synchronization restored. Performing scheduled switchover. Correlation ID: dbswitchover215.'
);

1 row created.

SQL> INSERT INTO app_logs (log_timestamp, log_message) VALUES (
  TO_DATE('2025-03-24 03:15:12', 'YYYY-MM-DD HH24:MI:SS'),
  'ERROR: Database Cluster: Primary database unreachable, initiating failover to standby. Correlation ID: dbfailover102.'
);

1 row created.

SQL> COMMIT;

Commit complete.

-- create data engineer agent
SQL> BEGIN
      DBMS_CLOUD_AI_AGENT.CREATE_AGENT(
        agent_name => 'Data_Engineer',
        attributes => '{"profile_name": "GOOGLE",
                        "role": "You are a specialized data ingestion engineer with expertise in   ' ||
                         'retrieving and processing data from complex database systems."
               }'
      );
    END;
    /
PL/SQL procedure successfully completed.

-- create ops manager agent
SQL> BEGIN
      DBMS_CLOUD_AI_AGENT.CREATE_AGENT(
        agent_name => 'Ops_Manager',
        attributes => '{"profile_name": "OPENAI",
                        "role": "You are an experienced Ops manager who excels at analyzing ' ||
                'complex log data, diagnosing the issues."
         }'
      );
    END;
    /
 
 
PL/SQL procedure successfully completed.
 
-- create log_fetcher tool
-- fetch_logs is a customized procedure.
-- Please make sure you have created your own procedure before use it in the tool

--Create a customized fetch_logs procedure
SQL> CREATE OR REPLACE FUNCTION fetch_logs(since_date IN DATE) RETURN CLOB IS
  l_logs CLOB;
BEGIN
  SELECT JSON_ARRAYAGG(log_message RETURNING CLOB)
    INTO l_logs
    FROM app_logs
   WHERE log_timestamp >= since_date
   ORDER BY log_timestamp;

  RETURN l_logs;
EXCEPTION
  WHEN OTHERS THEN
    RETURN 'Error fetching logs: ' || SQLERRM;
END fetch_logs;
/

Function created.

SQL> BEGIN
      DBMS_CLOUD_AI_AGENT.CREATE_TOOL(
        tool_name => 'log_fetcher',
        attributes => '{"instruction": "retrieves and returns all log messages with a LOG_TIMESTAMP greater than or equal to the input date.",
                        "function": "fetch_logs"}'
      );
    END;
    /
 
PL/SQL procedure successfully completed.
 
-- create task with log fetcher tool

SQL> BEGIN
      DBMS_CLOUD_AI_AGENT.CREATE_TASK(
        task_name  => 'fetch_logs_task',
        attributes => '{"instruction": "Fetch the log entries from the database based on user request: {query}}.",
                        "tools": ["log_fetcher"]}'
      );
    END;
    /
 
PL/SQL procedure successfully completed.
 
-- create task with predefined rag and slack tool

SQL> BEGIN
      DBMS_CLOUD_AI_AGENT.create_task(
        task_name => 'analyze_log_task',
        attributes => '{"instruction": "Analyze the fetched log entries retrieved based on user request: {query} ' ||
                      'Generate a detailed report include issue analysis and possible solution.",
           "input" : "fetch_logs_task"
        }'
     );
    END;
    /
 
PL/SQL procedure successfully completed.

-- create team and set agent team
SQL> BEGIN
      DBMS_CLOUD_AI_AGENT.create_team(
        team_name  => 'Ops_Issues_Solution_Team',
        attributes => '{"agents": [{"name":"Data_Engineer","task" : "fetch_logs_task"},
                                    {"name":"Ops_Manager","task" : "analyze_log_task"}],
                "process": "sequential"
                }');
    END;
    /
 
PL/SQL procedure successfully completed.
 
SQL> EXEC DBMS_CLOUD_AI_AGENT.SET_TEAM('Ops_Issues_Solution_Team');
 
 
PL/SQL procedure successfully completed.
 

SQL> select ai agent fetch and analyze the logs after 03/15 2025;
 
RESPONSE
-----------------------------------------------------------------------------------------------------------------------------------------------
1. Issue: High volume of 500 Internal Server Errors between 03/22 and 03/24.
   Solution: Review server application logs to identify failing components; add better exception handling and fallback mechanisms to prevent service crashes.
 
2. Issue: Increased response time on /api/v1/user and /checkout, peaking on 03/25.
   Solution: Profile backend queries and services, apply caching where applicable, and offload static content to a CDN.
 
3. Issue: Detected brute-force login attack with over 500 failed POST attempts from a single IP.
   Solution: Add rate-limiting, temporary IP bans, and CAPTCHA on the /login endpoint to prevent credential stuffing.
 
4. Issue: Suspicious User-Agent headers such as curl/7.58.0 or empty headers mimicking mobile devices.
   Solution: Block malformed or uncommon User-Agent strings and log them for threat intelligence analysis.
 
5. Issue: DDoS-like traffic spike from distributed IPs observed on 03/20.
   Solution: Enable DDoS protection at the CDN or cloud provider level, and configure autoscaling to absorb burst traffic.

Exemple : Créer un outil HTTP personnalisé

Cet exemple définit une fonction PL/SQL qui envoie une demande HTTP GET et retourne le texte de la réponse. La fonction est ensuite ajoutée dans l'outil Select AI Agent.

Vous pouvez créer un outil personnalisé qui envoie une demande REST à l'aide de la procédure DBMS_CLOUD.SEND_REQUEST et retourne la réponse sous forme de texte. Cet exemple montre comment écrire la fonction PL/SQL et l'ajouter en tant qu'outil à utiliser dans les tâches d'agent.

La fonction get_url_content envoie une demande GET à l'URL cible et retourne la réponse en tant que CLOB. DBMS_CLOUD_AI_AGENT.CREATE_TOOL utilise la fonction get_url_content et crée un outil nommé HTTP_TOOL que l'agent Select AI peut appeler lorsqu'une tâche nécessite d'extraire du contenu à partir d'une URL. 

CREATE OR REPLACE FUNCTION get_url_content (
    url IN CLOB
) RETURN CLOB
AS
    l_resp   DBMS_CLOUD_TYPES.RESP;
    l_result CLOB;
BEGIN
    l_resp := DBMS_CLOUD.SEND_REQUEST(
                credential_name => NULL,
                method          => 'GET',
                uri             => url
             );
    l_result := DBMS_VECTOR_CHAIN.UTL_TO_TEXT(DBMS_CLOUD.GET_RESPONSE_RAW(l_resp);
    RETURN l_result;
END get_url_content;
/

BEGIN
  DBMS_CLOUD_AI_AGENT.create_tool(
    tool_name  => 'HTTP_TOOL',
    attributes => '{
      "instruction": "This tool fetches and returns the plain text content from the specified URL. ",
      "function": "get_url_content"
    }'
  );
END;
/

Exemple : Voir les invites et les réponses de l'agent à partir de la dernière exécution d'équipe

Cet exemple aide à déboguer l'activité récente Sélectionner un agent d'intelligence artificielle en affichant des invites, des réponses et des pensées d'agent de l'équipe d'agent la plus récente exécutée à l'aide de vues historiques et de données de conversation.

Cet exemple extrait et affiche des journaux détaillés de l'exécution la plus récente de l'équipe Select AI Agent. L'exemple utilise les vues USER_AI_AGENT_TEAM_HISTORY, USER_AI_AGENT_TASK_HISTORY et USER_CLOUD_AI_CONVERSATION_PROMPTS pour afficher le nom de l'équipe, la tâche, les invites associées et les réponses de chaque agent. Utilisez cette interrogation pour résoudre les problèmes en consultant à la fois l'invite d'entrée et les réponses générées par la dernière exécution de l'équipe. 

WITH latest_team AS (
  SELECT team_exec_id, team_name, start_date
  FROM user_ai_agent_team_history
  ORDER BY start_date DESC
  FETCH FIRST 1 ROW ONLY
),
latest_task AS (
    SELECT team_exec_id, task_name, agent_name, conversation_params, start_date,
           ROW_NUMBER() OVER (PARTITION BY team_exec_id, task_name, agent_name 
                             ORDER BY start_date DESC) as rn
  FROM user_ai_agent_task_history
)
SELECT
  team.team_name,
  task.task_name,
  task.agent_name,
  p.prompt,
  p.prompt_response
FROM latest_team team
JOIN latest_task task
  ON team.team_exec_id = task.team_exec_id
 AND task.rn = 1
LEFT JOIN user_cloud_ai_conversation_prompts p
  ON p.conversation_id = JSON_VALUE(task.conversation_params, '$.conversation_id')
ORDER BY task.start_date DESC NULLS LAST,
         p.created     DESC NULLS LAST;
Cet exemple extrait des journaux détaillés à partir des vues de l'historique des outils, des tâches et des équipes. Utilisez les interrogations suivantes pour vérifier l'utilisation de l'outil, des tâches et de l'équipe, résoudre les problèmes et analyser les journaux. Les interrogations utilisent des vues USER_AI_AGENT_TOOL_HISTORY, USER_AI_AGENT_TASK_HISTORY et USER_AI_AGENT_TASK_HISTORY.
--View the tool history

select * from USER_AI_AGENT_TOOL_HISTORY
order by START_DATE desc

--View the task history

select * from USER_AI_AGENT_TASK_HISTORY
order by START_DATE desc

--View the team history
select * from USER_AI_AGENT_TEAM_HISTORY
order by START_DATE desc

Exemple : Reprendre une exécution d'équipe d'agent à partir de l'état WAITING_FOR_HUMAN

Cet exemple montre comment reprendre l'exécution d'une équipe d'agent lorsque le statut de l'historique des tâches est WAITING_FOR_HUMAN. Lorsqu'une équipe d'agent passe à l'état WAITING_FOR_HUMAN, elle est suspendue jusqu'à ce qu'un utilisateur fournisse l'entrée ou la confirmation suivante. Vous pouvez reprendre l'exécution en fonction de la façon dont vous utilisez l'équipe de l'agent : sur la ligne de commande SQL ou au moyen de DBMS_CLOUD_AI_AGENT.RUN_TEAM.

Exemple : Reprendre une exécution d'équipe d'agent à l'aide de la ligne de commande SQL

Si vous utilisez SELECT AI AGENT <prompt> sur la ligne de commande SQL, la sélection de l'agent d'intelligence artificielle reprend automatiquement l'exécution de l'équipe en pause. Le contexte de conversation, y compris les invites et le raisonnement antérieurs, est maintenu sans nécessiter de paramètres supplémentaires.

Exemple : Reprendre une exécution d'équipe d'agent à l'aide de DBMS_CLOUD_AI_AGENT.RUN_TEAM

Si vous utilisez la procédure DBMS_CLOUD_AI_AGENT.RUN_TEAM, vous pouvez reprendre une équipe d'agent en pause en transmettant la même conversation_id qui a été utilisée lors de l'exécution initiale. L'état d'exécution de l'équipe d'agent, y compris les actions en attente et le contexte, est conservé et l'équipe d'agent continue exactement d'où elle s'est arrêtée.

Voir pour un exemple à l'aide de la fonction DBMS_CLOUD_AI_AGENT.RUN_TEAM. 

--Interact with the agent
DECLARE
  v_response VARCHAR2(4000);
BEGIN
  v_response :=  DBMS_CLOUD_AI_AGENT.RUN_TEAM(
    team_name   => '<same initial team name>',
    user_prompt => 'response to request',
    params      => '{"conversation_id": "<same initial conversation_id>"}'
  );
  DBMS_OUTPUT.PUT_LINE(v_response);
END;