Démarrage express

Accorder l'accès au niveau de la location

Pour autoriser un groupe d'utilisateurs à gérer toutes les ressources d'IA générative dans la location, procédez comme suit :

allow group <your-group-name> to manage generative-ai-family 
in tenancy

Octroi de l'accès au niveau du compartiment

Pour définir la portée de l'accès à un compartiment spécifique, procédez comme suit :

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

Une fois ces autorisations en place, vous êtes prêt à créer le premier projet.

Rechercher l'OCID de clé d'API

Pour définir la portée des droits d'accès à une clé d'API spécifique, vous avez besoin de son OCID.

Dans la console :

1. Accédez à la page de liste des clés d'API.
2. Sélectionnez la clé d'API que vous avez créée.
3. Copiez l'OCID (il commence généralement par ocid1.generativeaiapikey...).

Accorder le droit d'accès à la clé d'API

Créez une stratégie IAM pour autoriser la clé d'API à appeler l'API des réponses :

allow group <your-group-name> 
to manage generative-ai-response in tenancy where ALL 
{request.principal.type='generativeaiapikey', 
request.principal.id='<your-api-key-OCID>'}

Cette stratégie permet aux demandes authentifiées avec la clé d'API indiquée d'accéder à l'API des réponses, tout en gardant l'accès étendu et contrôlé.

URL de base 🔗

Utilisez l'URL de base suivante pour accéder à l'API OCI Responses :

https://inference.generativeai.<region>.oci.oraclecloud.com/openai/v1

Remplacez <region> par l'identificateur de région approprié (par exemple, us-chicago-1).

Prise en charge du kit SDK 🔗

L'API des réponses OCI est compatible avec le kit SDK OpenAI, qui est recommandé pour interagir avec le service. Il est pris en charge dans de nombreux langages, notamment Python, Java, TypeScript, Go et .NET.

Vous pouvez également l'utiliser avec des structures d'agent populaires telles que LangChain, LlamaIndex et OpenAI Agents SDK.

Quand utiliser l'authentification IAM

Envisagez d'utiliser l'authentification IAM dans les cas suivants :

• Exécution d'applications dans les services OCI (par exemple, Functions ou OKE)
• Eviter les informations d'identification de longue durée, telles que les clés d'API
• Application du contrôle d'accès de niveau fin via des stratégies IAM

Installation de la bibliothèque d'authentification OCI IAM

Installez la bibliothèque oci-genai-auth, qui fournit des utilitaires d'aide pour l'intégration de l'authentification OCI IAM au kit SDK OpenAI :

pip install oci-genai-auth

Cette bibliothèque inclut les aides à l'authentification suivantes :

• OciSessionAuth (pour le développement local)
• OciUserPrincipalAuth
• OciInstancePrincipalAuth
• OciResourcePrincipalAuth (pour les environnements gérés par OCI)

Configurer le client OpenAI

Lors de l'utilisation de l'authentification IAM, initialisez le client OpenAI avec un client HTTP personnalisé et un gestionnaire d'authentification. Dans ce cas, la valeur api_key est "not used".

Exemple : Développement local (OciSessionAuth)

Utilisez cette approche lorsque vous exécutez du code localement (par exemple, sur un ordinateur portable à l'aide d'un profil d'interface de ligne de commande OCI) :

from openai import OpenAI
from oci_openai import OciSessionAuth
import httpx

client = OpenAI(
    base_url="https://inference.generativeai.us-chicago-1.oci.oraclecloud.com/openai/v1",  # update region if needed
    api_key="not-used",
    project="ocid1.generativeaiproject.oc1.us-chicago-1.xxxxxxxx",  # project OCID created earlier
    http_client=httpx.Client(auth=OciSessionAuth(profile_name="DEFAULT"))  # update profile if needed
)

response = client.responses.create(
    model="xai.grok-4-1-fast-reasoning",
    input="Write a one-sentence explanation of what a database is."
)

print(response.output_text)

Exemple : environnements gérés par OCI (OciResourcePrincipalAuth)

Utilisez cette approche lorsque vous exécutez des services OCI tels qu'OCI Functions ou OCI Container Engine for Kubernetes (OKE) :

Utilisation de l'authentification OCI IAM

Si vous avez ajouté les stratégies dans Prérequis : configuration des droits d'accès IAM, ignorez cette étape.

Pour autoriser un groupe d'utilisateurs à appeler l'API des réponses, ajoutez la stratégie suivante :

allow group <your-group-name> 
to manage generative-ai-response in tenancy

Si vous utilisez l'authentification par clé d'API d'IA générative

Lors de l'utilisation de l'authentification par clé d'API, une autre stratégie est requise pour autoriser les demandes effectuées avec la clé d'API. Si vous avez ajouté les stratégies dans 3. Ajouter un droit d'accès à la clé d'API, ignorez cette étape.

Pour accorder l'accès à une clé d'API spécifique, procédez comme suit :

allow group <your-group-name> 
to manage generative-ai-response in tenancy 
where ALL {request.principal.type='generativeaiapikey', 
request.principal.id='<your-api-key-OCID>'}

Pour un accès plus large (par exemple lors des tests), vous pouvez utiliser une stratégie plus générale :

allow any-user 
to manage generative-ai-family in tenancy 
where ALL {request.principal.type='generativeaiapikey', 
request.principal.id='<your-api-key-OCID>'}

Ces stratégies garantissent que les demandes, qu'elles soient authentifiées via IAM ou des clés d'API, sont autorisées à accéder aux ressources OCI Generative AI.

Modèles hébergés tiers

OCI Generative AI fournit un accès aux modèles de fournisseurs tiers. Indiquez le modèle en utilisant son nom qualifié complet :

response = client.responses.create(
    model="xai.grok-4-1-fast-reasoning",
    input="Write a one-sentence explanation of what a database is."
)

response = client.responses.create(
    model="google.gemini-2.5-pro",
    input="Write a one-sentence explanation of what a database is."
)

Modèles à la demande

Les modèles à la demande sont hébergés et gérés par OCI et sont disponibles sans infrastructure dédiée :

response = client.responses.create(
    model="openai.gpt-oss-120b",
    input="Write a one-sentence explanation of what a database is."
)

Clusters d'IA dédiés (mode dédié)

Pour les charges de travail de production nécessitant une isolation ou des performances prévisibles, vous pouvez déployer des modèles sur un cluster d'IA dédié. Dans ce cas, utilisez l'OCID d'adresse de cluster comme identificateur de modèle :

response = client.responses.create(
    model="<dedicated-ai-cluster-endpoint-ocid>",
    input="Write a one-sentence explanation of what a database is."
)

Diffuser tous les événements

response_stream = client.responses.create(
    model="openai.gpt-oss-120b",
    input="Explain the difference between structured and unstructured data.",
    stream=True
)

for event in response_stream:
    print(event)

Sortie de texte de flux uniquement (jetons delta)

response_stream = client.responses.create(
    model="openai.gpt-oss-120b",
    input="Explain the difference between structured and unstructured data.",
    stream=True
)

for event in response_stream:
    if event.type == "response.output_text.delta":
        print(event.delta, end="", flush=True)

Le streaming est particulièrement utile pour les applications interactives où vous souhaitez afficher les réponses aux utilisateurs au fur et à mesure de leur génération.

Intégration aux outils d'observabilité 🔗

Pour obtenir des informations plus approfondies telles que la latence, les coûts et les traces d'exécution, vous pouvez intégrer l'API OCI Responses aux plates-formes d'observabilité.

De nombreux fournisseurs prennent en charge les API compatibles OpenAI. L'une de ces options est Langfuse, une plate-forme d'ingénierie LLM open source qui aide les développeurs à déboguer, surveiller et améliorer les applications LLM. Il fournit une observabilité de bout en bout pour le suivi des actions de l'agent, prend en charge la gestion des versions rapide et aide à l'évaluation des sorties du modèle. Langfuse s'intègre aux structures populaires telles qu'OpenAI, LangChain et LlamaIndex.

L'exemple suivant montre comment utiliser Langfuse pour suivre et surveiller les appels d'API Responses.

Etape 1 : installation du kit SDK Langfuse

pip install langfuse

Etape 2 : Configurer les variables d'environnement

Définissez les variables d'environnement Langfuse et OCI requises :

LANGFUSE_SECRET_KEY="sk-lf-xxxxxxxxx"
LANGFUSE_PUBLIC_KEY="pk-lf-xxxxxxxxx"
LANGFUSE_BASE_URL="https://us.cloud.langfuse.com"

# OCI Generative AI credentials
OCI_GENAI_API_KEY="sk-xxxxxxxxx"
OCI_GENAI_PROJECT_ID="ocid1.generativeaiproject.oc1.xxx"

Étape 3 : Instrumenter le client OpenAI

Importez le client OpenAI à partir du SDK Langfuse. Le code existant reste inchangé, mais les demandes sont automatiquement tracées.

import os
from langfuse.openai import OpenAI  # Import from Langfuse

client = OpenAI(
    base_url="https://inference.generativeai.us-ashburn-1.oci.oraclecloud.com/openai/v1",
    api_key=os.getenv("OCI_GENAI_API_KEY"),
    project=os.getenv("OCI_GENAI_PROJECT_ID"),
)

# Requests are automatically instrumented by Langfuse
response = client.responses.create(
    model="openai.gpt-oss-120b",
    tools=[
        {
            "type": "mcp",
            "server_label": "dmcp",
            "server_url": "https://mcp.deepwiki.com/mcp",
            "require_approval": "never",
        },
    ],
    input="Explain why tracing and observability are important in distributed systems."
)

print(response.output_text)

Cette intégration offre une visibilité de bout en bout sur les appels d'API sans nécessiter de modification importante du code de votre application.

Entrée d'image en tant qu'URL de données codées en Base64

import base64

def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode("utf-8")

base64_image = encode_image("/path/to/image.png")

response = client.responses.create(
    model="openai.gpt-oss-120b",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Describe the main objects in this image."},
                {
                    "type": "input_image",
                    "image_url": f"data:image/jpeg;base64,{base64_image}",
                    "detail": "high",
                },
            ],
        }
    ],
)

print(response.output_text)

Saisie d'image en tant qu'URL accessible par Internet

response = client.responses.create(
    model="openai.gpt-oss-120b",
    store=False,
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Describe the scene shown in this image."},
                {
                    "type": "input_image",
                    "image_url": "https://example.photos/id/123",
                },
            ],
        }
    ],
)

print(response.output_text)

Remplacez "image_url" par une URL d'image valide.

Entrée de fichier en tant qu'ID de fichier

file = client.files.create(
    file=open("<path-to-file>", "rb"),
    purpose="user_data"
)

response = client.responses.create(
    model="google.gemini-2.5-pro",
    input=[
        {
            "role": "user",
            "content": [
                {
                    "type": "input_file",
                    "file_id": file.id,
                },
                {
                    "type": "input_text",
                    "text": "Summarize this document.",
                },
            ]
        }
    ]
)

print(response.output_text)

Entrée de fichier en tant qu'URL accessible par Internet

response = client.responses.create(
    model="google.gemini-2.5-flash",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Summarize this file."},
                {
                    "type": "input_file",
                    "file_url": "https://www.example.com/letters/example-letter.pdf",
                },
            ],
        }
    ],
)

print(response.output_text)

Effort de raisonnement

import json

response = client.responses.create(
    model="openai.gpt-oss-120b",
    input="Solve 18 * (4 + 2).",
    reasoning={"effort": "medium"},
    store=False,
)

print(response.output_text)

Sortie de synthèse du raisonnement

Si vous créez un chatbot, l'activation de résumés de raisonnement peut aider les utilisateurs à mieux comprendre comment le modèle est arrivé à un résultat. Pendant la diffusion en continu, les utilisateurs peuvent également voir des jetons de raisonnement pendant que le modèle réfléchit.

import json

response = client.responses.create(
    model="openai.gpt-oss-120b",
    input="Solve 18 * (4 + 2).",
    reasoning={"summary": "auto"},
    store=False,
)

print(response.output_text)

Ce qui permet

Les outils de fonction sont utiles lorsque l'application doit garder le contrôle de l'exécution tout en permettant au modèle de décider quand des informations externes sont nécessaires.

Les cas d'emploi les plus courants sont :

• Recherche d'événements de calendrier
• Extraction des données d'application
• Appel d'API internes ou externes
• Exécuter une logique métier ou des calculs

Cette approche vous offre de la flexibilité tout en conservant le chemin d'exécution dans l'application.

Flux d'exécution 🔗

Une interaction type d'un outil fonctionnel fonctionne comme suit :

1. Le client envoie une demande qui inclut une ou plusieurs définitions d'outil.
2. Le modèle décide si l'un de ces outils est nécessaire.
3. Si un outil est nécessaire, le modèle renvoie le nom et les arguments de l'outil.
4. L'application exécute l'outil et prépare le résultat.
5. L'application renvoie ce résultat dans une demande de suivi.
6. Le modèle utilise ce résultat pour terminer la réponse.

Options de traitement d'état 🔗

Il existe deux façons courantes de gérer l'état de ces demandes :

• Etat géré par le service : recommandé pour la plupart des cas d'utilisation. La demande de suivi inclut previous_response_id et le service suit l'échange précédent.
• Etat géré par le client : l'application conserve l'historique complet des interactions et envoie le contexte cumulé à chaque demande.

Définir un outil de fonction

L'exemple suivant définit un outil qui extrait les événements de calendrier pour une date spécifiée.

tools = [
    {
        "type": "function",
        "name": "get_calendar_events",
        "description": "Return calendar events scheduled for a specific date.",
        "parameters": {
            "type": "object",
            "properties": {
                "date": {
                    "type": "string",
                    "description": "Date to query, for example 2026-04-02"
                }
            },
            "required": ["date"],
        },
    },
]

Incluez ce tableau tools dans la demande client.responses.create().

Exemple : état géré par le service

Dans ce modèle, la première demande permet au modèle de décider si l'outil est nécessaire. La seconde demande renvoie le résultat de l'outil et référence la réponse précédente.

import json

tools = [
    {
        "type": "function",
        "name": "get_calendar_events",
        "description": "Return calendar events scheduled for a specific date.",
        "parameters": {
            "type": "object",
            "properties": {
                "date": {
                    "type": "string",
                    "description": "Date to query, for example 2026-04-02"
                }
            },
            "required": ["date"],
        },
    },
]

def get_calendar_events(date):
    # Replace this with actual calendar logic or an API call
    return [
        {"time": "09:00", "title": "Team standup"},
        {"time": "13:00", "title": "Design review"},
        {"time": "16:00", "title": "Project check-in"},
    ]

# Initial request
response = client.responses.create(
    model="openai.gpt-oss-120b",
    tools=tools,
    input="Show the calendar events for 2026-04-02.",
)

# Execute the requested function
tool_outputs = []
for item in response.output:
    if item.type == "function_call" and item.name == "get_calendar_events":
        args = json.loads(item.arguments)
        events = get_calendar_events(**args)
        tool_outputs.append({
            "type": "function_call_output",
            "call_id": item.call_id,
            "output": json.dumps({"events": events}),
        })

# Follow-up request
final = client.responses.create(
    model="openai.gpt-oss-120b",
    instructions="Summarize the schedule clearly for the user.",
    tools=tools,
    input=tool_outputs,
    previous_response_id=response.id,
)

print(final.output_text)

Exemple : état géré par le service

Dans ce modèle, l'application conserve l'échange complet et le soumet à nouveau avec la demande de suivi.

import json

tools = [
    {
        "type": "function",
        "name": "get_calendar_events",
        "description": "Return calendar events scheduled for a specific date.",
        "parameters": {
            "type": "object",
            "properties": {
                "date": {
                    "type": "string",
                    "description": "Date to query, for example 2026-04-02"
                }
            },
            "required": ["date"],
        },
    },
]

def get_calendar_events(date):
    # Replace this with actual calendar logic or an API call
    return [
        {"time": "09:00", "title": "Team standup"},
        {"time": "13:00", "title": "Design review"},
        {"time": "16:00", "title": "Project check-in"},
    ]

conversation = [
    {"role": "user", "content": "Show the calendar events for 2026-04-02."}
]

response = client.responses.create(
    model="openai.gpt-oss-120b",
    tools=tools,
    input=conversation,
)

conversation += response.output

for item in response.output:
    if item.type == "function_call" and item.name == "get_calendar_events":
        args = json.loads(item.arguments)
        events = get_calendar_events(**args)
        conversation.append({
            "type": "function_call_output",
            "call_id": item.call_id,
            "output": json.dumps({"events": events}),
        })

final = client.responses.create(
    model="openai.gpt-oss-120b",
    instructions="Summarize the schedule clearly for the user.",
    tools=tools,
    input=conversation,
)

print(final.output_text)

Les outils fonctionnels sont une option puissante lorsque l'application doit rester responsable de l'exécution, du contrôle d'accès et de la logique d'intégration, tout en permettant au modèle de demander les informations dont il a besoin.

Quand utiliser l'outil MCP

Utilisez l'outil MCP lorsque le modèle a besoin d'accéder à des fonctionnalités externes hébergées sur un serveur MCP.

Cette approche est utile lorsque vous voulez :

• Le service pour communiquer directement avec le serveur MCP
• Moins d'étapes d'orchestration côté client
• Latence plus faible qu'un modèle d'outil exécuté par le client
• Accès aux fonctionnalités exposées via un serveur MCP distant

L'outil MCP fait partie de l'ensemble d'outils OCI Generative AI et peut être utilisé avec d'autres outils pris en charge.

Soutien au transport

L'appel MCP distant utilise le HTTP Streamable.

Définition d'un outil MCP

Ajoutez la définition du serveur MCP dans le champ tools de la demande.

response_stream = client.responses.create(
    model="xai.grok-code-fast-1",
    tools=[
        {
            "type": "mcp",
            "server_label": "calendar",
            "server_description": "An MCP server that retrieves calendar events for a specified date.",
            "server_url": "https://example.com/mcp",
            "require_approval": "never",
        },
    ],
    input="What events are scheduled for 2026-04-02?",
    stream=True,
)

for event in response_stream:
    if event.type == "response.output_text.delta":
        print(event.delta, end="", flush=True)

Cet exemple transmet la réponse et imprime le texte au fur et à mesure qu'il est généré.

Limitation des outils exposés par le serveur MCP

Si le serveur MCP distant affiche plus d'outils que nécessaire pour l'application, vous pouvez affiner l'ensemble disponible à l'aide de allowed_tools.

response_stream = client.responses.create(
    model="openai.gpt-oss-120b",
    tools=[
        {
            "type": "mcp",
            "server_label": "calendar",
            "server_description": "An MCP server that retrieves calendar events for a specified date.",
            "server_url": "https://example.com/mcp",
            "require_approval": "never",
            "allowed_tools": ["get_events"],
        },
    ],
    input="Show the calendar events for 2026-02-02.",
    stream=True,
    store=False,
)

Authentification du serveur MCP

response_stream = client.responses.create(
    model="xai.grok-4-1-fast-reasoning",
    tools=[
        {
            "type": "mcp",
            "server_label": "calendar",
            "server_url": "https://calendar.example.com/mcp",
            "authorization": "$CALENDAR_OAUTH_ACCESS_TOKEN"
        },
    ],
    input="List my meetings for 2026-02-02.",
    stream=True,
    store=False,
)

Transmettez uniquement la valeur de jeton. N'incluez pas le préfixe Bearer. OCI envoie le jeton via TLS dans le cadre de la demande et ne le décode pas, ne l'inspecte pas, ne le stocke pas et ne le consigne pas.

Hébergement de serveur MCP

OCI Generative AI fournit également un hébergement de serveur MCP pour aider à déployer et à faire évoluer les serveurs MCP.

L'outil MCP est une bonne option lorsque vous souhaitez qu'OCI Generative AI fonctionne directement avec un serveur MCP distant lors de l'exécution de la demande, sans nécessiter que l'application client gère chaque étape de l'outil elle-même.

Préparer un magasin de vecteurs

Avant d'utiliser File Search, créez une banque de vecteurs et ajoutez les fichiers que le modèle doit référencer. OCI Generative AI prend en charge plusieurs modèles de traitement de fichiers via des API qui suivent le style d'API OpenAI Files.

Exemple

Pour rendre la recherche de fichier disponible dans une demande, ajoutez une entrée d'outil avec type: "file_search" et fournissez l'ID de banque de vecteurs.

response = client.responses.create(
    model="openai.gpt-oss-120b",
    input="Summarize the main ideas covered in the documents in this vector store.",
    tools=[
        {
            "type": "file_search",
            "vector_store_ids": ["<vector_store_id>"]
        }
    ]
)

print(response)

Pour quoi l'utiliser

Si vous l'utilisez pour la première fois, il est utile de penser à Code Interpreter comme un espace de travail Python temporaire pour le modèle.

Vous pouvez l'utiliser pour des tâches telles que :

• résolution de problèmes mathématiques
• analyse des fichiers téléchargés
• nettoyage ou transformation de données
• création de graphiques ou de tableaux
• génération de fichiers de sortie tels que des journaux ou des jeux de données traités

Environnement d'exécution

L'environnement Python comprend plus de 420 bibliothèques préinstallées, de nombreuses tâches courantes fonctionnent sans configuration supplémentaire.

Le code est exécuté dans un conteneur. Ce conteneur est l'environnement de travail où Python est exécuté et où les fichiers sont stockés pendant la session.

Limites de mémoire du conteneur

Les conteneurs d'interpréteur de code utilisent un pool de mémoire partagée de 64 Go par location.

Les tailles de conteneur prises en charge sont les suivantes :

• 1 Go
• 4 Go
• 16 Go
• 64 Go

Cette limite partagée peut être divisée entre plusieurs conteneurs. Par exemple, il peut prendre en charge :

• soixante-quatre conteneurs de 1 Go
• seize conteneurs de 4 Go
• quatre conteneurs de 16 Go
• un conteneur de 64 Go

Si vous avez besoin de plus de capacité, vous pouvez soumettre une demande de service.

Expiration du conteneur

Un conteneur expire après 20 minutes d'inactivité.

Ceci est important à savoir lors de la création de flux à plusieurs étapes :

• un conteneur expiré ne peut pas être réutilisé
• vous devez créer un conteneur
• les fichiers doivent être chargés à nouveau si nécessaire
• L'état en mémoire, comme les variables Python, est perdu

Pour cette raison, il est préférable de traiter les conteneurs comme des environnements de travail temporaires.

Exemple

response = client.responses.create(
    model="xai.grok-4-1-fast-reasoning",
    tools=[
        {
            "type": "code_interpreter",
            "container": {"type": "auto"}
        }
    ],
    instructions="Use the python tool to solve the problem and explain the result.",
    input="Find the value of (18 / 3) + 7 * 2."
)

print(response.output_text)

Conteneurs pour l'interprète de code

L'interpréteur de code a besoin d'un conteneur. Le conteneur est l'environnement isolé où le modèle exécute du code Python.

Un conteneur peut contenir :

• fichiers téléchargés
• fichiers créés par le modèle
• données de travail temporaires pendant l'exécution

Lorsque vous utilisez l'interpréteur de code, vous pouvez affecter l'un des deux modes de conteneur suivants :

• auto : OCI Generative AI crée le conteneur pour vous et affecte automatiquement une taille de conteneur.
• OCID de conteneur : vous créez le conteneur vous-même, définissez la taille du conteneur et fournissez l'OCID.

Pour les deux options, les conteneurs sont créés et gérés dans OCI Generative AI. Le code qui s'exécute dans ces conteneurs s'exécute également dans la location OCI Generative AI.

Mode automatique

En mode automatique, le service crée le conteneur pour vous. C'est l'option la plus simple et un bon point de départ pour la plupart des utilisateurs.

Utiliser le mode automatique lorsque :

• vous voulez qu'OCI Generative AI gère le conteneur
• vous n'avez pas besoin de contrôle direct sur l'environnement
• vous voulez une configuration plus simple

response = client.responses.create(
    model="xai.grok-code-fast-1",
    tools=[{
        "type": "code_interpreter",
        "container": {
            "type": "auto"
        }
    }],
    input="Use the python tool to calculate the average of 12, 18, 24, and 30."
)

Mode explicite

En mode explicite, vous créez d'abord le conteneur et définissez sa taille. Ensuite, vous transmettez l'ID de conteneur dans la demande.

Utilisez le mode explicite lorsque vous souhaitez plus de contrôle sur les spécificités du conteneur, telles que la taille de la mémoire.

container = client.containers.create(name="test-container", memory_limit="4g")

response = client.responses.create(
    model="xai.grok-code-fast-1",
    tools=[{
        "type": "code_interpreter",
        "container": container.id
    }],
    tool_choice="required",
    input="Use the python tool to calculate the average of 12, 18, 24, and 30."
)

print(response.output_text)

Fichiers dans l'interpréteur de code

L'interpréteur de code peut utiliser des fichiers pendant la durée de vie du conteneur. Le modèle peut lire les fichiers que vous fournissez et peut également créer de nouveaux fichiers.

Cela est utile pour les workflows tels que :

• lecture d'un fichier CSV ou PDF
• génération d'un graphique
• enregistrement de la sortie traitée
• création de journaux ou de rapports

Persistance des fichiers 🔗

Les fichiers créés ou modifiés par l'outil python restent disponibles dans le même conteneur tant que le conteneur n'a pas expiré.

Cela signifie que le modèle peut s'appuyer sur les travaux antérieurs de la même session. Par exemple, il peut :

1. lire un fichier
2. l'analyser
3. enregistrer un graphique
4. utiliser ce graphique ultérieurement dans le même conteneur

Lorsque le conteneur expire, cet état n'est plus disponible.

Téléchargement et gestion de fichiers 🔗

Vous pouvez gérer les fichiers conteneur via les API de fichier conteneur.

Les opérations courantes sont les suivantes :

• Créer un fichier conteneur : ajoutez un fichier au conteneur.
• Liste des fichiers de conteneur : visualisez les fichiers dans le conteneur.
• Supprimer un fichier conteneur : enlever un fichier
• Extraire le contenu du fichier conteneur : téléchargez un fichier à partir du conteneur.

Vous pouvez ainsi utiliser le conteneur en tant qu'espace de travail temporaire pour l'exécution de code basé sur un modèle.

Fichiers de sortie et citations 🔗

Lorsque le modèle crée des fichiers, ces fichiers sont stockés dans le conteneur et peuvent être référencés dans la réponse.

Ces références incluent :

• container_id
• file_id
• filename

Vous pouvez utiliser ces valeurs pour extraire le contenu du fichier généré.

L'API des réponses OCI prend en charge les adresses compatibles OpenAI pour des fonctionnalités telles que les réponses, les fichiers, les conteneurs et les fichiers de conteneur. Pour cette raison, la documentation OpenAI associée peut être utilisée comme référence pour la structure des demandes, les formats de réponse et les workflows généraux. Toutefois, lorsque vous utilisez ces API avec OCI, envoyez des demandes aux adresses d'inférence OCI Generative AI, utilisez l'authentification OCI et notez que les ressources et l'exécution restent dans OCI Generative AI, et non dans une location OpenAI.

Prérequis

Avant d'utiliser l'outil NL2SQL, commencez par créer une base de données et configurez les connexions de base de données requises.

Pour plus d'informations, reportez-vous à :

• Clonage d'une instance de base de données Autonomous AI
• Utilisation de la console Oracle Cloud Infrastructure

Autorisations pour les magasins sémantiques

Accès aux clés secrètes

Autorisez le groupe à lire les clés secrètes utilisées par Database Tools :

allow group <your-group-name> 
to read secret-family in compartment <your-compartment-name> 
where all {request.principal.type='generativeaisemanticstore'}

Accès aux connexions Database Tools

Autorisez le groupe à accéder aux ressources Database Tools requises :

allow group <your-group-name> 
to use database-tools-family in compartment <compartment-name> 
where all {request.principal.type='generativeaisemanticstore'}

allow group <your-group-name> 
to read database-family in compartment <compartment-name> 
where all {request.principal.type='generativeaisemanticstore'}

allow group <your-group-name> 
to read autonomous-database-family in compartment <compartment-name> 
where all {request.principal.type='generativeaisemanticstore'}

Accès aux sources Generative AI

Si la stratégie plus large ci-dessous est déjà en place, elle inclut l'accès aux ressources de magasin sémantique :

allow group <your-group-name> 
to manage generative-ai-family in tenancy

Si vous souhaitez un accès plus restreint, utilisez plutôt la stratégie suivante pour autoriser le groupe à créer et à gérer des magasins sémantiques :

allow group <your-group-name> 
to manage generative-ai-semantic-store 
in compartment <your-compartment-name>

Si le groupe n'a besoin que d'utiliser une banque sémantique existante et d'appeler NL2SQL, utilisez les stratégies plus spécifiques suivantes :

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

allow group <your-group-name> 
to manage generative-ai-nl2sql 
in compartment <your-compartment-name>

Chaînage de réponses

Avec le chaînage des réponses, chaque nouvelle réponse pointe vers la précédente. Il s'agit d'une option simple lorsque vous voulez reporter le contexte sans créer explicitement de ressource de conversation.

# first turn
response1 = client.responses.create(
    model="openai.gpt-oss-120b",
    input="Give me three ideas for a team offsite.",
)
print("Response 1:", response1.output_text)

# second turn
response2 = client.responses.create(
    model="openai.gpt-oss-120b",
    input="Make the second idea more budget friendly.",
    previous_response_id=response1.id,
)
print("Response 2:", response2.output_text)

API de conversations

# create a conversation
conversation = client.conversations.create(
    metadata={"topic": "demo"}
)
print("Conversation ID:", conversation.id)

# first turn
response1 = client.responses.create(
    model="openai.gpt-oss-120b",
    input="Give me three ideas for a team offsite.",
    conversation=conversation.id,
)
print("Response 1:", response1.output_text)

# second turn
response2 = client.responses.create(
    model="openai.gpt-oss-120b",
    input="Make the second idea more budget friendly.",
    conversation=conversation.id,
)
print("Response 2:", response2.output_text)