Agents d'OpenAI

Microsoft Agent Framework prend en charge plusieurs types de clients OpenAI. En C#, cela inclut la complétion de chat, les réponses et les assistants. Dans Python, les principales fonctionnalités d'OpenAI proposées par le fournisseur sont la complétion de chat et les réponses :

Type de Client	API	Idéal pour
Complétion des conversations	API de complétion de chat	Agents simples, prise en charge d’un modèle large
Réponses	API de réponses	Agents complets avec des outils hébergés (interpréteur de code, recherche de fichiers, recherche web, MCP hébergé)
Assistants	Assistants API	Agents gérés par le serveur avec interpréteur de code et recherche de fichiers

La disponibilité de la langue varie. Python utilise les clients pour la complétion de chat et les réponses sur cette page, la section sur les assistants ci-dessous est C# uniquement.

Getting Started

Ajoutez les packages NuGet requis à votre projet.

dotnet add package Microsoft.Agents.AI.OpenAI --prerelease

Client d’achèvement de conversation

Le client Chat Completion offre un moyen simple de créer des agents à l’aide de l’API ChatCompletion.

using Microsoft.Agents.AI;
using OpenAI;

OpenAIClient client = new OpenAIClient("<your_api_key>");
var chatClient = client.GetChatClient("gpt-4o-mini");

AIAgent agent = chatClient.AsAIAgent(
    instructions: "You are good at telling jokes.",
    name: "Joker");

Console.WriteLine(await agent.RunAsync("Tell me a joke about a pirate."));

Outils pris en charge : Outils de fonction, recherche web, outils MCP locaux.

Réponses client

Le client Réponses fournit la prise en charge des outils les plus riches, notamment l’interpréteur de code, la recherche de fichiers, la recherche web et le MCP hébergé.

using Microsoft.Agents.AI;
using OpenAI;

OpenAIClient client = new OpenAIClient("<your_api_key>");
var responsesClient = client.GetResponseClient("gpt-4o-mini");

AIAgent agent = responsesClient.AsAIAgent(
    instructions: "You are a helpful coding assistant.",
    name: "CodeHelper");

Console.WriteLine(await agent.RunAsync("Write a Python function to sort a list."));

Outils pris en charge : Outils de fonction, approbation des outils, interpréteur de code, recherche de fichiers, recherche web, mcP hébergé, outils MCP locaux.

Assistants du Client

Le client Assistants crée des agents gérés par le serveur avec l’interpréteur de code intégré et la recherche de fichiers.

using Microsoft.Agents.AI;
using OpenAI;

OpenAIClient client = new OpenAIClient("<your_api_key>");
var assistantsClient = client.GetAssistantClient();

// Assistants are managed server-side
AIAgent agent = assistantsClient.AsAIAgent(
    instructions: "You are a data analysis assistant.",
    name: "DataHelper");

Console.WriteLine(await agent.RunAsync("Analyze trends in the uploaded data."));

Outils pris en charge : Outils de fonction, interpréteur de code, recherche de fichiers, outils MCP locaux.

Conseil / Astuce

Consultez les exemples .NET pour obtenir des exemples exécutables complets.

Utilisation de l’agent

Les trois types de clients produisent une norme AIAgent qui prend en charge les mêmes opérations d’agent (streaming, threads, middleware).

Pour plus d’informations, consultez les didacticiels De prise en main.

Conseil / Astuce

Dans Python, Azure OpenAI utilise désormais les mêmes agent_framework.openai clients présentés ici. Transmettez des entrées de routage Azure explicites telles que credential ou azure_endpoint lorsque vous souhaitez un routage Azure, puis définissez api_version la surface d’API Azure que vous souhaitez utiliser. S’il OPENAI_API_KEY est configuré, les clients génériques restent sur OpenAI même lorsque les variables AZURE_OPENAI_* sont également présentes. Si vous disposez déjà d'une URL complète .../openai/v1, utilisez base_url plutôt que azure_endpoint. Pour les points de terminaison de projet Microsoft Foundry et le service Foundry Agent, consultez la page du fournisseur Microsoft Foundry. Pour les runtimes locaux, consultez Foundry Local.

Installation

pip install agent-framework-openai

agent-framework-openai est le package de fournisseur Python facultatif pour l’utilisation directe d’OpenAI et d’Azure OpenAI.

Paramétrage

Les clients de conversation Python OpenAI utilisent ces modèles de variables d’environnement :

Complétion des conversations

OPENAI_API_KEY="your-openai-api-key"
OPENAI_CHAT_COMPLETION_MODEL="gpt-4o-mini"
# Optional shared fallback:
# OPENAI_MODEL="gpt-4o-mini"

Réponses

OPENAI_API_KEY="your-openai-api-key"
OPENAI_CHAT_MODEL="gpt-4o-mini"
# Optional shared fallback:
# OPENAI_MODEL="gpt-4o-mini"

Azure OpenAI avec les mêmes clients

Azure OpenAI utilise désormais les mêmes clients Python OpenAI que openAI direct. Le modèle Azure préféré et le plus clair consiste à passer des entrées de routage Azure explicites telles que credential ou azure_endpoint, puis définies api_version pour Azure une fois le routage sélectionné. Si OPENAI_API_KEY est définie, les clients génériques restent sur OpenAI, sauf si vous fournissez ces entrées de routage Azure. Si vous avez uniquement des paramètres AZURE_OPENAI_*, le repli de l’environnement Azure fonctionne toujours. OpenAIChatClient préfère AZURE_OPENAI_CHAT_MODEL, OpenAIChatCompletionClient préfère AZURE_OPENAI_CHAT_COMPLETION_MODEL, et les deux reviennent à AZURE_OPENAI_MODEL.

AZURE_OPENAI_ENDPOINT="https://<resource>.openai.azure.com"
AZURE_OPENAI_CHAT_MODEL="gpt-4o-mini"
# Optional shared fallback:
# AZURE_OPENAI_MODEL="gpt-4o-mini"
AZURE_OPENAI_API_VERSION="your-api-version"

import asyncio
import os
from agent_framework.openai import OpenAIChatClient
from azure.identity import AzureCliCredential

async def main():
    agent = OpenAIChatClient(
        model=os.environ["AZURE_OPENAI_CHAT_MODEL"],
        azure_endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
        api_version=os.getenv("AZURE_OPENAI_API_VERSION"),
        credential=AzureCliCredential(),
    ).as_agent(
        name="AzureOpenAIResponsesAgent",
        instructions="You are a helpful assistant.",
    )

    result = await agent.run("Hello!")
    print(result)

asyncio.run(main())

Si vous avez déjà une URL Azure OpenAI complète qui se termine /openai/v1par , passez-la comme base_url au lieu de azure_endpoint. Gardez api_version aligné à l’interface de l’API Azure OpenAI que vous utilisez. Si OPENAI_API_KEY est également définie dans votre environnement, ces entrées explicites d'Azure gardent le client sur Azure.

Note

Utiliser OpenAIChatClient pour l’API Réponses. Pour l’authentification de clé Azure, vous pouvez toujours passer api_key, mais credential= il s’agit maintenant de la surface d’authentification Azure préférée.

Vecteurs Azure avec la même catégorie de clients

OpenAIEmbeddingClient suit les mêmes règles de routage que les clients de conversation. Pour les incorporations Azure, transmettez le déploiement d’incorporation en tant que model et privilégiez les entrées Azure explicites.

import os
from agent_framework.openai import OpenAIEmbeddingClient
from azure.identity import AzureCliCredential

client = OpenAIEmbeddingClient(
    model=os.environ["AZURE_OPENAI_EMBEDDING_MODEL"],
    azure_endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
    api_version=os.getenv("AZURE_OPENAI_API_VERSION"),
    credential=AzureCliCredential(),
)

Créer des agents OpenAI

Complétion des conversations

OpenAIChatCompletionClient utilise l’API de complétion de chat — l'option la plus simple avec une large prise en charge des modèles.

import asyncio
from agent_framework.openai import OpenAIChatCompletionClient

async def main():
    agent = OpenAIChatCompletionClient().as_agent(
        name="HelpfulAssistant",
        instructions="You are a helpful assistant.",
    )
    result = await agent.run("Hello, how can you help me?")
    print(result)

asyncio.run(main())

Outils pris en charge : Outils de fonction, recherche web, outils MCP locaux.

Recherche web avec achèvement de chat

async def web_search_example():
    client = OpenAIChatCompletionClient()
    web_search = client.get_web_search_tool()

    agent = client.as_agent(
        name="SearchBot",
        instructions="You can search the web for current information.",
        tools=web_search,
    )
    result = await agent.run("What are the latest developments in AI?")
    print(result)

Réponses

OpenAIChatClient utilise l’API Réponses ( option la plus riche en fonctionnalités avec les outils hébergés).

import asyncio
from agent_framework.openai import OpenAIChatClient

async def main():
    agent = OpenAIChatClient().as_agent(
        name="FullFeaturedAgent",
        instructions="You are a helpful assistant with access to many tools.",
    )
    result = await agent.run("Write and run a Python script that calculates fibonacci numbers.")
    print(result)

asyncio.run(main())

Outils pris en charge : Outils de fonction, approbation des outils, interpréteur de code, recherche de fichiers, recherche web, mcP hébergé, outils MCP locaux.

Outils hébergés avec le client de réponses

Le client Réponses fournit des get_*_tool() méthodes pour chaque type d’outil hébergé :

async def hosted_tools_example():
    client = OpenAIChatClient()

    # Each tool is created via a client method
    code_interpreter = client.get_code_interpreter_tool()
    web_search = client.get_web_search_tool()
    file_search = client.get_file_search_tool(vector_store_ids=["vs_abc123"])
    mcp_tool = client.get_mcp_tool(
        name="GitHub",
        url="https://api.githubcopilot.com/mcp/",
        approval_mode="never_require",
    )

    agent = client.as_agent(
        name="PowerAgent",
        instructions="You have access to code execution, web search, files, and GitHub.",
        tools=[code_interpreter, web_search, file_search, mcp_tool],
    )
    result = await agent.run("Search the web for Python best practices, then write a summary.")
    print(result)

Important

Python ne fournit plus de client/fournisseur de compatibilité Assistants. Pour le code Python actuel, utilisez OpenAIChatClient pour les scénarios d’API Réponses ou OpenAIChatCompletionClient pour les Achèvements de chat. Si vous avez besoin d’un agent géré par le service dans Microsoft Foundry, consultez la page du fournisseur Microsoft Foundry.

Fonctionnalités courantes

Ces types de clients prennent en charge ces fonctionnalités d’agent standard :

Outils de fonction

from agent_framework import tool

@tool
def get_weather(location: str) -> str:
    """Get the weather for a given location."""
    return f"The weather in {location} is sunny, 25°C."

async def example():
    agent = OpenAIChatClient().as_agent(
        instructions="You are a weather assistant.",
        tools=get_weather,
    )
    result = await agent.run("What's the weather in Tokyo?")
    print(result)

Conversations à plusieurs tours

async def thread_example():
    agent = OpenAIChatClient().as_agent(
        instructions="You are a helpful assistant.",
    )
    session = await agent.create_session()

    result1 = await agent.run("My name is Alice", session=session)
    print(result1)
    result2 = await agent.run("What's my name?", session=session)
    print(result2)  # Remembers "Alice"

Diffusion en continu

async def streaming_example():
    agent = OpenAIChatClient().as_agent(
        instructions="You are a creative storyteller.",
    )
    print("Agent: ", end="", flush=True)
    async for chunk in agent.run("Tell me a short story about AI.", stream=True):
        if chunk.text:
            print(chunk.text, end="", flush=True)
    print()

Utilisation de l’agent

Tous les types de clients produisent une norme Agent qui prend en charge les mêmes opérations.

Pour plus d’informations, consultez les didacticiels De prise en main.

Prochaines étapes

Microsoft Foundry