API OCI Réponses

Utilisez l'API de réponses avec les composants de création d'agent suivants dans OCI Generative AI :

Si nécessaire, vous pouvez utiliser les blocs de base de bas niveau avec l'API Réponses.

Utilisez l'API des réponses pour :

• Appelez les modèles hébergés pris en charge et les modèles importés.
• Envoyer des entrées de texte et d'image et recevoir des sorties de texte.
• Générer du texte ou des sorties structurées.
• Exécuter des invites en une seule étape ou des workflows en plusieurs étapes.
• Ajoutez les outils pris en charge dans la demande.
• Diffusez les réponses vers le client.
• Utilisez l'état de conversation géré par OCI via l'API Conversations.
• Réutiliser l'historique des conversations ou les sorties précédentes comme contexte pour les demandes ultérieures.
• Connectez le modèle aux systèmes et données externes via l'appel de fonction et l'appel MCP.
• Combinez les demandes de modèle avec des fichiers, des banques de vecteurs ou des conteneurs si nécessaire.

Vous pouvez ainsi commencer par une simple invite et passer à des workflows plus avancés sans passer à une autre API.

Pour la plupart des nouvelles applications, commencez par l'API Réponses.

Utilisez-le lorsque vous souhaitez :

• Utiliser une API pour les fonctionnalités d'interaction de modèle et agénétiques.
• Ajoutez les outils pris en charge à une demande de modèle.
• Utilisez l'historique des conversations géré par OCI.
• Générer des sorties structurées.
• Créez des workflows qui peuvent également utiliser des fichiers, des banques de vecteurs ou des conteneurs si nécessaire.

Remplacez ${region} par une région OCI prise en charge telle que us-chicago-1.

Bien que le format de demande soit compatible avec OpenAI, l'authentification utilise les informations d'identification OCI, les demandes sont acheminées via les adresses d'inférence OCI Generative AI et les ressources et l'exécution restent dans OCI.

Vous pouvez accéder aux adresses compatibles avec OCI OpenAI de deux manières :

• Clés d'API OCI Generative AI
• Authentification basée sur OCI IAM

Utiliser des clés d'API pour les tests et le développement anticipé. Utilisez l'authentification basée sur IAM pour les workloads de production et les environnements gérés par OCI.

Avant d'appeler l'API des réponses :

• Créez un projet OCI Generative AI. Les appels d'API compatibles avec OCI OpenAI nécessitent un projet.
• Configurez le client à l'aide de l'URL de base compatible OCI OpenAI.
• Configurez l'authentification.
• Utilisez un modèle pris en charge dans une région prise en charge.

Pour connaître les étapes de configuration, reportez-vous à QuickStart, à Authentification et à Modèles et régions pris en charge.

Pour appeler l'API des réponses à partir du code, nous vous recommandons d'utiliser le kit SDK OpenAI. Reportez-vous à Démarrage rapide.

L'exemple suivant utilise le kit SDK OpenAI avec l'adresse compatible OCI OpenAI, une clé d'API OCI Generative AI et un OCID de projet :

from openai import OpenAI

client = OpenAI(
    base_url="https://inference.generativeai.us-chicago-1.oci.oraclecloud.com/openai/v1",
    api_key="sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
    project="ocid1.generativeaiproject.oc1.us-chicago-1.xxxxxxxx",
)

response = client.responses.create(
    model="<supported-model-id>",
    input="Write a one-sentence explanation of what a database is."
)

print(response.output_text)

Dans cet exemple :

• base_url pointe vers l'adresse compatible avec OCI OpenAI.
• client.responses.create(...) appelle l'API OCI Responses.
• project identifie le projet OCI Generative AI pour la demande.

Pour permettre à OCI de gérer l'historique des conversations multi-tours, commencez par créer une conversation :

conversation = client.conversations.create()

Incluez ensuite l'ID de conversation dans la demande d'API des réponses :

response = client.responses.create(
  model="<supported-model-id>",
  input=[
        {
            "role": "user",
            "content": "Recommend a restaurant based on the food I like."
        }
    ],
    conversation=conversation.id,
)

Utilisez ce modèle lorsque vous voulez qu'OCI gère l'état des conversations entre les demandes.

Pour plus d'informations sur les fonctionnalités de mémoire, reportez-vous à API Conversations, Mémoire à court terme, Mémoire à long terme et Compaction de mémoire à court terme.

L'API Réponses prend en charge les workflows avec outils via la propriété tools. Pour de nombreux cas d'utilisation, vous pouvez déclarer les outils de la demande et laisser OCI Generative AI coordonner l'exécution du modèle et l'utilisation des outils.

La prise en charge des outils n'est disponible que via l'API.

L'exemple suivant définit un outil MCP dans la demande :

response = client.responses.create(
    model="openai.gpt-oss-120b",
    tools=[
        {
            "type": "mcp",
            "server_url": "https://example.com/mcp",
        }
    ],
    input="What events are scheduled for 2026-04-02?"
)

Dans cet exemple, l'API Responses appelle le modèle et transmet la définition de l'outil MCP dans le cadre de la même demande. Vous n'avez pas besoin d'une API distincte propre à MCP.

Vous pouvez utiliser les blocs de base de l'agent de bas niveau avec l'API Responses lorsque votre workflow a besoin d'un contrôle direct sur les fichiers, les banques de vecteurs ou les conteneurs.

Exemples courants :

• Chargement des fichiers avant l'envoi d'une demande de modèle
• Gestion directe du contenu de la banque de vecteurs
• Réutilisation de fichiers ou de ressources sur plusieurs demandes
• Utiliser des conteneurs de modèle d'environnement restreint dans le cadre d'un workflow plus large

L'API suivante est couramment utilisée avec l'API Réponses :

file_response = client.files.create(
    file=open("example-document.pdf", "rb"),
    purpose="assistants"
)

file_id = file_response.id

response = client.responses.create(
    model="<model-id>",
    input=[
        {
            "role": "user",
            "content": [
                { "type": "input_file", "file_id": file_id },
                { "type": "input_text", "text": "List all the cities mentioned in this document." }
            ]
        }
    ]
)

Vous pouvez utiliser l'API OCI Responses avec le kit SDK OpenAI. Vous pouvez également l'utiliser avec des structures d'agent côté client compatibles.

Le kit SDK OpenAI prend en charge les langages suivants :

• Python
• Java
• TypeScript
• Accéder
• .NET

Plus de soutien linguistique est disponible dans les bibliothèques communautaires.

Les structures d'agent compatibles incluent :

• SDK d'agents OpenAI (recommandé)
• SDK OpenAI Codex
• Structure d'agent Microsoft
• LangChain
• Langgraph
• IAEquipe
• Génération automatique
• LlamaIndex
• Pydantique

• API de conversations
• Outils d'API de réponses
  • Recherche de fichier
  • Interpréteur de code
  • Appel de fonction
  • Appel MCP
• API de fichiers
• API des magasins de vecteurs
• API Containers
• Authentification
  • Clés d'API OCI Generative AI
  • Authentification basée sur OCI IAM
• Modèles et régions pris en charge
• Démarrage express