Démarrage rapide

Accorder l'accès au niveau de la location

Pour permettre à un groupe d'utilisateurs de gérer toutes les ressources du service d'intelligence artificielle générative dans l'ensemble de la location :

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

Accorder l'accès au niveau du compartiment

Pour définir la portée de l'accès à un compartiment spécifique :

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 la clé d'API

Pour étendre les autorisations à une clé d'API spécifique, vous avez besoin de son OCID.

Dans la console :

1. Naviguez jusqu'à la page de liste 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 l'autorisation à la clé d'API

Créez une politique IAM pour autoriser la clé d'API à appeler l'API de 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 politique permet aux demandes authentifiées avec la clé d'API spécifiée d'accéder à l'API 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 de réponses OCI :

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 de la trousse SDK 🔗

L'API des réponses OCI est compatible avec la trousse SDK OpenAI, qui est recommandée 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 cadres d'agent populaires tels que LangChain, LlamaIndex et OpenAI Agents SDK.

Quand utiliser l'authentification IAM

Envisagez d'utiliser l'authentification IAM lorsque :

• Exécution d'applications dans les services OCI (par exemple, Functions ou OKE)
• Éviter les données d'identification de longue durée telles que les clés d'API
• Application d'un contrôle d'accès détaillé au moyen de politiques IAM

Installer la bibliothèque d'authentification IAM pour OCI

Installez la bibliothèque oci-genai-auth, qui fournit des utilitaires d'aide pour intégrer l'authentification OCI IAM à la trousse SDK OpenAI :

pip install oci-genai-auth

Cette bibliothèque comprend les outils d'aide à l'authentification suivants :

• 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 et un programme de traitement d'authentification personnalisés. La valeur api_key est "not used" dans ce cas.

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 OCI (OciResourcePrincipalAuth)

Utilisez cette approche lors de l'exécution dans des services OCI tels que le service Fonctions OCI ou OCI Container Engine pour Kubernetes (OKE) :

Si vous utilisez l'authentification OCI IAM

Si vous avez ajouté les politiques sous Préalable : Configurer les autorisations IAM, ignorez cette étape.

Pour permettre à un groupe d'utilisateurs d'appeler l'API Réponses, ajoutez la politique suivante :

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

Si vous utilisez l'authentification par clé d'API du service d'intelligence artificielle générative

Lors de l'utilisation de l'authentification par clé d'API, une autre politique est requise pour autoriser les demandes effectuées avec la clé d'API. Si vous avez ajouté les politiques dans 3. Ajouter une autorisation à la clé d'API, ignorez cette étape.

Pour accorder l'accès à une clé d'API spécifique :

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 politique 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 politiques garantissent que les demandes, qu'elles soient authentifiées au moyen du service IAM ou de clés d'API, sont autorisées à accéder aux ressources d'IA générative pour OCI.

Modèles hébergés par une tierce partie

OCI Generative AI donne accès à des modèles de fournisseurs tiers. Spécifiez le modèle à l'aide de son nom 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 sur demande

Les modèles sur demande sont hébergés et gérés par OCI et sont disponibles sans nécessiter d'infrastructure dédiée :

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

Grappes dédiées à l'IA (mode dédié)

Pour les charges de travail de production nécessitant un isolement ou une performance prévisible, vous pouvez déployer des modèles sur une grappe dédiée à l'IA. Dans ce cas, utilisez l'OCID du point d'extrémité de grappe 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 seulement (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)

La diffusion en continu est particulièrement utile pour les applications interactives où vous voulez afficher les réponses aux utilisateurs au fur et à mesure de leur génération.

Intégrer à Observability Tools 🔗

Pour obtenir des informations plus détaillées, telles que les traces de latence, de coût et 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 à code source libre 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 d'agent, prend en charge le contrôle des versions rapide et facilite l'évaluation des sorties de modèle. Langfuse s'intègre à des frameworks populaires tels que OpenAI, LangChain et LlamaIndex.

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

Étape 1 : Installer le SDK Langfuse

pip install langfuse

Étape 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 de la trousse SDK Langfuse. Le code existant reste inchangé, mais les demandes sont automatiquement suivies.

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 fournit une visibilité de bout en bout des appels d'API sans nécessiter de modifications importantes du code d'application.

Entrée d'image en tant qu'URL de données encodé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)

Entrée 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 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)

Raisonnement de l'effort

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 du sommaire des motifs

Si vous créez un agent conversationnel, l'activation de sommaires de raisonnement peut aider les utilisateurs à mieux comprendre comment le modèle est arrivé à un résultat. Pendant le streaming, 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 que cela 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'utilisation typiques sont les suivants :

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

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

Flux d'exécution 🔗

Une interaction d'outil de fonction typique fonctionne comme suit :

1. Le client envoie une demande qui inclut une ou plusieurs définitions d'outils.
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 :

• État géré par le service : Recommandé pour la plupart des cas d'utilisation. La demande de suivi inclut previous_response_id et le service effectue le suivi de l'échange précédent.
• État 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 deuxième demande renvoie le résultat de l'outil et renvoie à 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 excellente option 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 souhaitez :

• Le service pour communiquer directement avec le serveur MCP
• Moins d'étapes d'orchestration côté client
• Latence inférieure à celle d'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 du jeu d'outils d'IA générative d'OCI et peut être utilisé avec d'autres outils pris en charge.

Soutien au transport

L'appel MCP distant utilise le protocole HTTP évolutif.

Définir 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 montre comment diffuser la réponse et imprimer le texte au fur et à mesure qu'il est généré.

Restreindre les outils exposés par le serveur MCP

Si le serveur MCP distant expose plus d'outils que les besoins de l'application, vous pouvez restreindre le jeu 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,
)

Fournir l'authentification au 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 du jeton. N'incluez pas le préfixe Bearer. OCI envoie le jeton sur TLS dans le cadre de la demande et ne le décode pas, ne l'inspecte pas, ne le stocke pas ou 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 à adapter les serveurs MCP.

L'outil MCP est une bonne option lorsque vous souhaitez que l'IA générative OCI fonctionne directement avec un serveur MCP distant lors de l'exécution de la demande, sans que l'application client ne doive gérer chaque étape de l'outil elle-même.

Préparer un magasin de vecteurs

Avant d'utiliser la recherche de fichiers, créez un magasin de vecteurs et ajoutez les fichiers auxquels le modèle doit faire référence. OCI Generative AI prend en charge plusieurs modèles de traitement de fichier au moyen d'API respectant 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 magasin vectoriel.

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)

Ce pour quoi vous pouvez l'utiliser

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

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

• résoudre des problèmes mathématiques
• analyse des fichiers chargés
• nettoyage ou transformation des données
• création de graphiques ou de tables
• 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 s'exécute dans un conteneur. Ce conteneur est l'environnement de travail où Python s'exécute et où les fichiers sont stockés pendant la session.

Limites de mémoire du conteneur

Les conteneurs de l'interpréteur de code utilisent un groupe de mémoire partagé 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 pourrait soutenir :

• 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é.

Il est important de savoir lors de la création de flux en plusieurs étapes :

• un conteneur expiré ne peut pas être réutilisé
• vous devez créer un nouveau conteneur
• les fichiers doivent être chargés à nouveau si nécessaire
• l'état in-memory, 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éteur 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 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 : Le service d'intelligence artificielle générative pour OCI crée le conteneur pour vous et affecte automatiquement une taille de conteneur.
• OCID du conteneur : Vous créez le conteneur vous-même, vous définissez sa taille et vous indiquez son OCID.

Pour les deux options, les conteneurs sont créés et gérés dans le service IA générative pour OCI. Le code qui s'exécute dans ces conteneurs s'exécute également dans la location du service d'intelligence artificielle générative pour OCI.

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 d'un 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. Vous transmettez ensuite l'ID conteneur dans la demande.

Utilisez le mode explicite lorsque vous souhaitez mieux contrôler 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

Code Interpreter peut travailler avec 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.

Ceci est utile pour les flux de travail 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 des travaux antérieurs dans la même session. Par exemple, il peut :

1. lire un fichier
2. analyser
3. enregistrer un graphique
4. utiliser ce graphique plus tard dans le même conteneur

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

Chargement et gestion des fichiers 🔗

Vous pouvez gérer les fichiers de conteneur au moyen des API.

Les opérations courantes sont les suivantes :

• Créer un fichier de conteneur : Ajoutez un fichier au conteneur
• Lister les fichiers de conteneur : Voir les fichiers dans le conteneur
• Supprimer un fichier de conteneur : Supprimer un fichier
• Extraire le contenu du fichier de conteneur : Téléchargez un fichier à partir du conteneur

Cela vous permet d'utiliser le conteneur comme espace de travail temporaire pour l'exécution de code basée sur un modèle.

Fichiers de sortie et citations 🔗

Lorsque le modèle crée des fichiers, ceux-ci 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 OCI Responses prend en charge les points d'extrémité compatibles avec OpenAI pour des fonctions telles que les réponses, les fichiers, les conteneurs et les fichiers 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 flux de travail généraux. Toutefois, lors de l'utilisation de ces API avec OCI, envoyez des demandes aux points d'extrémité d'inférence de l'IA générative pour OCI, utilisez l'authentification OCI et notez que les ressources et l'exécution restent dans l'IA générative pour OCI, et non dans une location OpenAI.

Préalables

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

Pour plus d'informations, voir :

• Cloner une instance de base de données d'IA autonome
• Utilisation de la console Oracle Cloud Infrastructure

Autorisations pour les magasins sémantiques

Accès aux clés secrètes

Accordez au groupe l'accès pour lire les clés secrètes utilisées par le service d'outils de base de données :

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

Accès aux connexions au service d'outils de base de données

Accordez au groupe l'accès aux ressources du service d'outils de base de données 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 ressources de l'IA générative

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

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

Si vous voulez un accès plus étroit, utilisez plutôt la politique suivante pour permettre au groupe de créer et de 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 un magasin sémantique existant et d'appeler NL2SQL, utilisez les politiques 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îne de réponses

Avec l'enchaînement des réponses, chaque nouvelle réponse pointe vers la précédente. Il s'agit d'une option simple lorsque vous souhaitez transférer le contexte sans créer explicitement une 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 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)