API de réponses OCI

Utilisez l'API Réponses avec les composants de création d'agent suivants dans le service d'intelligence artificielle générative pour OCI :

Si nécessaire, vous pouvez utiliser les blocs fonctionnels de bas niveau avec l'API Responses.

Utilisez l'API Réponses pour :

• Appeler les modèles hébergés et les modèles importés pris en charge.
• 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 flux de travail en plusieurs étapes.
• Ajoutez les outils pris en charge dans la demande.
• Transmettre les réponses au client.
• Utilisez l'état de conversation géré par OCI au moyen de l'API Conversations.
• Réutiliser l'historique de conversation 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 magasins vectoriels ou des conteneurs, au besoin.

Cela vous permet de commencer par une invite simple et de passer à des flux de travail plus avancés sans passer à une autre API.

Pour la plupart des nouvelles applications, commencez par l'API Responses.

Utilisez-le lorsque vous souhaitez :

• Utiliser une API unique pour les interactions et les capacités agéntiques du modèle.
• Ajouter des outils pris en charge à une demande de modèle.
• Utilisez l'historique de conversation géré par OCI.
• Générer des sorties structurées.
• Créez des flux de travail qui peuvent également utiliser des fichiers, des magasins vectoriels ou des conteneurs, au besoin.

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

Bien que le format de la demande soit compatible avec OpenAI, l'authentification utilise les données d'identification OCI, les demandes sont acheminées au moyen des points d'extrémité d'inférence du service d'intelligence artificielle générative pour OCI et les ressources et l'exécution restent dans OCI.

Vous pouvez accéder aux points d'extrémité compatibles avec OCI OpenAI de deux façons :

• Clés d'API du service d'intelligence artificielle générative pour OCI
• Authentification basée sur OCI IAM

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

Avant d'appeler l'API Réponses :

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

Pour les étapes de configuration, voir QuickStart, Authentication et Modèles et régions pris en charge.

Pour appeler l'API de réponses à partir du code, nous vous recommandons d'utiliser la trousse SDK OpenAI. Voir QuickStart.

L'exemple suivant utilise la trousse SDK OpenAI avec le point d'extrémité 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 le point d'extrémité compatible OCI OpenAI.
• client.responses.create(...) appelle l'API de réponses OCI.
• project identifie le projet OCI Generative AI pour la demande.

Pour permettre à OCI de gérer l'historique de conversation à plusieurs tours, créez d'abord une conversation :

conversation = client.conversations.create()

Incluez ensuite l'ID conversation dans la demande d'API 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 de conversation entre les demandes.

Pour plus d'informations sur les capacités de mémoire, voir API de conversations, Mémoire à court terme, Mémoire à long terme et Compaction de mémoire à court terme.

L'API Réponses prend en charge les flux de travail activés pour l'outil au moyen de la propriété tools. Pour de nombreux cas d'utilisation, vous pouvez déclarer les outils dans la demande et laisser OCI Generative AI coordonner l'exécution du modèle et l'utilisation de l'outil.

La prise en charge des outils est disponible uniquement au moyen de 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 propre à MCP distincte.

Vous pouvez utiliser les blocs fonctionnels d'agent de base de bas niveau avec l'API Réponses lorsque votre flux de travail a besoin d'un contrôle direct sur les fichiers, les magasins vectoriels ou les conteneurs.

Exemples courants :

• Chargement de fichiers avant l'envoi d'une demande de modèle
• Gestion directe du contenu du magasin vectoriel
• Réutilisation de fichiers ou de ressources pour plusieurs demandes
• Utilisation de conteneurs de bac à sable dans le cadre d'un flux de travail plus large

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

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 de réponses OCI avec la trousse SDK OpenAI. Vous pouvez également l'utiliser avec des cadres d'agent côté client compatibles.

La trousse SDK OpenAI prend en charge ces langages :

• Python
• Java
• TypeScript
• Aller
• .NET

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

Les cadres d'agent compatibles incluent :

• Trousse SDK pour agents OpenAI (recommandée)
• OpenAI Codex SDK
• Cadre d'agent Microsoft
• LangChain
• LangGraph
• Équipage
• Génération automatique
• LlamaIndex
• Pydantique

• API Conversations
• Outils d'API de réponses
  • Recherche de fichier
  • Interpréteur de code
  • Appel de fonction
  • Appel MCP
• API Fichiers
• API de magasins de vecteurs
• API Conteneurs
• Authentification
  • Clés d'API du service d'intelligence artificielle générative pour OCI
  • Authentification basée sur OCI IAM
• Modèles et régions pris en charge
• Démarrage rapide