Informations de référence sur le SDK Foundry Local

Le Foundry Local SDK vous permet de proposer des fonctionnalités d’IA dans vos applications qui utilisent des modèles d’IA locaux par le biais d’une API simple et intuitive. Le Kit de développement logiciel (SDK) extrait la complexité de la gestion des modèles IA et offre une expérience transparente pour l’intégration des fonctionnalités d’IA locales dans vos applications. Cette référence documente les implémentations du Kit de développement logiciel (SDK) pour C#, C++, JavaScript, Python et Rust.

Le Kit de développement logiciel (SDK) ne nécessite pas l’installation de l’interface CLI locale Foundry sur l’ordinateur des utilisateurs finaux, ce qui vous permet d’expédier vos applications sans étapes de configuration supplémentaires pour vos utilisateurs. Vos applications sont autonomes. Les avantages supplémentaires du SDK Local Foundry sont les suivants :

Détection et optimisation du matériel : évaluation automatique des fonctionnalités pour GPU, NPU et PROCESSEUR.
Gestion des fournisseurs d’exécution (Windows) : téléchargement et inscription automatiques des fournisseurs d’exécution du runtime ONNX appropriés (CUDA, Vitis, QNN, OpenVINO, TensorRT) en fonction des fonctionnalités de l’appareil.
Prise en charge Metal via WebGpu (macOS) : prise en charge native de l’exécution de modèles sur Apple Silicon avec des performances optimisées.
Acquisition de modèles : téléchargement transparent à partir du catalogue de modèles Foundry, avec contrôle de version, mises à jour et sélection automatique de modèles optimisés pour le matériel, ainsi qu’une prise en charge de secours.
Exécution efficace : ajoute environ 20 Mo à la taille de l’application, s’exécute sur les appareils des téléphones mobiles vers les ordinateurs de bureau.
Compatibilité de l’API OpenAI : intégration facile aux modèles et outils OpenAI.
Serveur REST facultatif : Run Foundry Local en tant que service local accessible par d’autres applications.

Informations de référence sur le SDK C#

Installer des packages

dotnet add package Microsoft.AI.Foundry.Local
dotnet add package OpenAI

Les exemples C# dans le référentiel GitHub sont des projets préconfigurés. Si vous développez ex nihilo, vous devez lire la référence de Foundry Local SDK pour plus d’informations sur la configuration de votre projet C# avec Foundry Local.

configuration de Project

Les exemples de dépôts incluent un fichier .csproj qui gère automatiquement la détection de la plateforme. Si vous créez un projet à partir de zéro, utilisez cette configuration comme référence :

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <!-- Windows: target Windows SDK for WinML hardware acceleration -->
  <PropertyGroup Condition="$([MSBuild]::IsOSPlatform('Windows'))">
    <TargetFramework>net9.0-windows10.0.19041.0</TargetFramework>
    <Platforms>ARM64;x64</Platforms>
    <WindowsPackageType>None</WindowsPackageType>
    <EnableCoreMrtTooling>false</EnableCoreMrtTooling>
  </PropertyGroup>

  <!-- Non-Windows: standard .NET -->
  <PropertyGroup Condition="!$([MSBuild]::IsOSPlatform('Windows'))">
    <TargetFramework>net9.0</TargetFramework>
  </PropertyGroup>

  <PropertyGroup Condition="'$(RuntimeIdentifier)'==''">
    <RuntimeIdentifier>$(NETCoreSdkRuntimeIdentifier)</RuntimeIdentifier>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.AI.Foundry.Local" />
  </ItemGroup>

  <!-- Linux GPU support -->
  <ItemGroup Condition="'$(RuntimeIdentifier)' == 'linux-x64'">
    <PackageReference Include="Microsoft.ML.OnnxRuntime.Gpu" />
    <PackageReference Include="Microsoft.ML.OnnxRuntimeGenAI.Cuda" />
  </ItemGroup>

  <!-- Shared utilities -->
  <ItemGroup>
    <Compile Include="../Shared/*.cs" />
  </ItemGroup>

</Project>

Le tableau suivant explique les paramètres clés du projet :

Réglage	Description
`TargetFramework`	Cible la version .NET requise par l’exemple.
`RuntimeIdentifier`	L'identifiant d'environnement d'exécution par défaut du SDK actuel garantit que les fichiers binaires de la plateforme appropriée sont sélectionnés.
`Microsoft.AI.Foundry.Local`	Package du kit de développement logiciel (SDK) The Foundry Local pour Windows, macOS et Linux.

Démarrage rapide

Utilisez cet extrait de code pour vérifier que le Kit de développement logiciel (SDK) peut initialiser et accéder au catalogue de modèles local.

using Microsoft.AI.Foundry.Local;
using Microsoft.Extensions.Logging;
using System.Linq;

var config = new Configuration
{
  AppName = "app-name",
  LogLevel = Microsoft.AI.Foundry.Local.LogLevel.Information,
};

using var loggerFactory = LoggerFactory.Create(builder =>
{
  builder.SetMinimumLevel(Microsoft.Extensions.Logging.LogLevel.Information);
});
var logger = loggerFactory.CreateLogger<Program>();

await FoundryLocalManager.CreateAsync(config, logger);
var manager = FoundryLocalManager.Instance;

var catalog = await manager.GetCatalogAsync();
var models = await catalog.ListModelsAsync();

Console.WriteLine($"Models available: {models.Count()}");

Cet exemple montre comment imprimer le nombre de modèles disponibles pour votre matériel.

Échantillons

Pour obtenir des exemples d’applications qui montrent comment utiliser le Kit de développement logiciel (SDK) C# local Foundry, consultez le dépôt GitHub des exemples du SDK C# local Foundry .

Référence d’API

Pour plus d’informations sur le SDK C# local Foundry, consultez la référence de l’API du SDK C# Local Foundry.

API de transcription audio native

Le Kit de développement logiciel (SDK) C# inclut un client audio natif pour transcrire des fichiers audio sur l’appareil à l’aide de modèles Whisper. Cela exécute l’inférence in-process sans avoir besoin du serveur web REST.

Obtenir un client audio

Après le chargement d’un modèle Whisper, obtenez un client audio :

var audioClient = await model.GetAudioClientAsync();

Méthodes de transcription audio

Méthode	Signature	Description
`TranscribeAudioStreamingAsync()`	`(string audioFilePath, CancellationToken ct) => IAsyncEnumerable<TranscriptionChunk>`	Diffuse en continu les résultats de la transcription en segments. Chaque bloc a une `Text` propriété.

Paramètres AudioClient

Propriété	Type	Description
`Language`	`string`	Code de langage ISO 639-1 (par exemple, `"en"`). Améliore la précision.
`Temperature`	`float`	Température d’échantillonnage (0,0 à 1,0). Les valeurs inférieures sont plus déterministes.

Exemple

var audioClient = await model.GetAudioClientAsync();
audioClient.Settings.Language = "en";
audioClient.Settings.Temperature = 0.0f;

await foreach (var chunk in audioClient.TranscribeAudioStreamingAsync(
    "recording.mp3", CancellationToken.None))
{
    Console.Write(chunk.Text);
}

Références :

Transcrire des fichiers audio avec Foundry Local

Informations de référence sur le Kit de développement logiciel (SDK) JavaScript

Installer des packages

npm install foundry-local-sdk openai

Démarrage rapide

Utilisez cet extrait de code pour vérifier que le Kit de développement logiciel (SDK) peut initialiser et accéder au catalogue de modèles local.

import { FoundryLocalManager } from 'foundry-local-sdk';

console.log('Initializing Foundry Local SDK...');

const manager = FoundryLocalManager.create({
    appName: 'foundry_local_samples',
    logLevel: 'info'
});
console.log('✓ SDK initialized successfully');

// Explore available models
console.log('\nFetching available models...');
const catalog = manager.catalog;
const models = await catalog.getModels();

console.log(`Found ${models.length} models:`);
for (const model of models) {
    console.log(`  - ${model.alias}`);
}

Cet exemple génère la liste des modèles disponibles pour votre matériel.

Échantillons

Pour obtenir des exemples d'applications qui montrent comment utiliser le Foundry Local JavaScript SDK, consultez le Foundry Local JavaScript SDK Samples GitHub repository.

Référence d’API

Pour plus d’informations sur le SDK JavaScript local Foundry, consultez la référence de l’API du SDK JavaScript local Foundry.

References

Informations de référence sur Python SDK

Installer des packages

pip install foundry-local-sdk openai

Démarrage rapide

Utilisez cet extrait de code pour vérifier que le Kit de développement logiciel (SDK) peut initialiser et accéder au catalogue de modèles local.

import asyncio
from foundry_local_sdk import Configuration, FoundryLocalManager


async def main():
    config = Configuration(app_name="app-name")
    FoundryLocalManager.initialize(config)
    manager = FoundryLocalManager.instance

    models = manager.catalog.list_models()
    print(f"Models available: {len(models)}")


if __name__ == "__main__":
    asyncio.run(main())

Cet exemple montre comment imprimer le nombre de modèles disponibles pour votre matériel.

Échantillons

Pour obtenir des exemples d’applications qui montrent comment utiliser le Kit de développement logiciel (SDK) de Python local Foundry, consultez les exemples Foundry Local SDK GitHub référentiel.

Paramétrage

La Configuration classe vous permet de personnaliser le comportement du Kit de développement logiciel (SDK) :

from foundry_local_sdk import Configuration

config = Configuration(
    app_name="app-name",
    log_level="info",
    model_cache_dir="./foundry_local_data/model_cache",
    web={"urls": "http://127.0.0.1:55588"},
)

Paramètre	Type	Description
`app_name`	`str`	Nom de votre application.
`log_level`	`str`	Niveau de journalisation (par exemple, `"info"`, `"debug"`).
`model_cache_dir`	`str`	Répertoire pour les modèles mis en cache.
`web`	`dict`	Configuration du service web avec `urls` clé.

API principale

Méthode	Description
`FoundryLocalManager.initialize(config)`	Initialisez le gestionnaire singleton avec un `Configuration`.
`FoundryLocalManager.instance`	Accédez à l’instance du gestionnaire initialisé.
`manager.catalog.list_models()`	Répertorier tous les modèles disponibles dans le catalogue.
`manager.catalog.get_model(alias)`	Obtenir un modèle par alias.
`manager.catalog.get_cached_models()`	Répertorier les modèles dans le cache local.
`manager.catalog.get_loaded_models()`	Répertorier les modèles actuellement chargés.
`model.download(progress_callback)`	Téléchargez le modèle (ignore s’il est mis en cache).
`model.load()`	Chargez le modèle pour l’inférence.
`model.unload()`	Déchargez le modèle.
`model.is_cached`	Vérifiez si le modèle est mis en cache localement.
`model.is_loaded`	Vérifiez si le modèle est chargé.

API de complétions de chat native

Après le chargement d’un modèle, obtenez un client de conversation :

client = model.get_chat_client()

Méthode	Description
`client.complete_chat(messages)`	Générez une réponse de conversation complète.
`client.complete_streaming_chat(messages)`	Diffusion de segments de réponse de chat.

API de transcription audio native

Après le chargement d’un modèle Whisper, obtenez un client audio :

audio_client = model.get_audio_client()

Méthode	Description
`audio_client.transcribe(file_path)`	Transcrire un fichier audio. Retourne un objet avec une `text` propriété.

Références :

Référence SDK Rust

Installer des packages

cargo add foundry-local-sdk
cargo add tokio --features full
cargo add tokio-stream anyhow

Démarrage rapide

Utilisez cet extrait de code pour vérifier que le Kit de développement logiciel (SDK) peut initialiser et accéder au catalogue de modèles local.

use foundry_local_sdk::{FoundryLocalConfig, FoundryLocalManager};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let manager = FoundryLocalManager::create(FoundryLocalConfig::new("app-name"))?;

    let models = manager.catalog().get_models().await?;
    println!("Models available: {}", models.len());

    Ok(())
}

Cet exemple montre comment imprimer le nombre de modèles disponibles pour votre matériel.

Échantillons

Pour obtenir des exemples d’applications qui montrent comment utiliser le SDK Rust Foundry Local, consultez le référentiel GitHub Foundry Local SDK Samples.

Paramétrage

Le FoundryLocalConfig struct vous permet de personnaliser le comportement du Kit de développement logiciel (SDK) :

use foundry_local_sdk::FoundryLocalConfig;

let config = FoundryLocalConfig::new("app-name")
    .with_log_level("info")
    .with_model_cache_dir("./foundry_local_data/model_cache")
    .with_web_urls("http://127.0.0.1:55588");

API principale

Méthode	Description
`FoundryLocalManager::create(config)`	Créez un gestionnaire avec un `FoundryLocalConfig`.
`manager.catalog().get_models().await`	Répertorier tous les modèles disponibles.
`manager.catalog().get_model(alias).await`	Obtenir un modèle par alias.
`manager.catalog().get_cached_models().await`	Répertorier les modèles dans le cache local.
`manager.catalog().get_loaded_models().await`	Répertorier les modèles actuellement chargés.
`model.download(callback).await`	Téléchargez le modèle (ignore s’il est mis en cache).
`model.load().await`	Chargez le modèle pour l’inférence.
`model.unload().await`	Déchargez le modèle.

API de complétions de chat native

Après avoir chargé un modèle, créez un client de conversation avec des paramètres facultatifs :

let client = model.create_chat_client()
    .temperature(0.7)
    .max_tokens(256);

Méthode	Description
`client.complete_chat(&messages, tools).await`	Générez une réponse de conversation complète.
`client.complete_streaming_chat(&messages, tools).await`	Diffusion de segments de réponse de chat.

Types de messages : ChatCompletionRequestSystemMessage, ChatCompletionRequestUserMessage, ChatCompletionRequestMessage.

API de transcription audio native

Après avoir chargé un modèle Whisper, créez un client audio :

let audio_client = model.create_audio_client();

Méthode	Description
`audio_client.transcribe(file_path).await`	Transcrire un fichier audio. Retourne un objet avec un `text` champ.

Références :

Référence du SDK C++

Prerequisites

Le SDK C++ fournit un wrapper uniquement constitué d’en-têtes sur le runtime local Foundry natif. Votre application déployée ne nécessite pas l'interface CLI locale Foundry ou un runtime .NET.

Clonez l’exemple de conversation native pour commencer avec un projet CMake configuré :

git clone https://github.com/microsoft-foundry/foundry-samples.git
cd foundry-samples/samples/cpp/foundry-local/native-chat-completions

Les exemples C++ nécessitent :

CMake 3.20 ou version ultérieure.
Un compilateur C++20.
NuGet CLI sur votre PATH.

Configurez et générez l’exemple :

cmake -S . -B build
cmake --build build --config Release

Pendant la configuration, l’exemple restaure la version 2.2.1 du package NuGet Microsoft.AI.Foundry.Local.Runtime dans build/_packages. Le package contient les en-têtes C++ et les bibliothèques natives pour Windows, Linux et macOS. Vous n’avez pas besoin d’un package WinML distinct.

La configuration CMake sélectionne les ressources d’exécution de votre système d’exploitation et de votre architecture et copie les bibliothèques natives requises en regard de l’exécutable. Sur macOS et Linux, exécutez l’exécutable à partir de build. Sur Windows, exécutez le fichier .exe à partir de build.

Sélectionnez des ressources natives qui correspondent au système d’exploitation et à l’architecture de votre application :

Système d'exploitation	Architecture	Identifiant d'exécution (RID)
Windows	x64 ou ARM64	`win-x64` ou `win-arm64`
Linux	x64 ou ARM64	`linux-x64` ou `linux-arm64`
macOS	Apple silicon (ARM64)	`osx-arm64`

Ajouter build/_packages/Microsoft.AI.Foundry.Local.Runtime.2.2.1/build/native/include au chemin d'inclusion de votre compilateur. Lier la bibliothèque native à partir du fichier build/_packages/Microsoft.AI.Foundry.Local.Runtime.2.2.1/runtimes/<rid>/native répertoire:

foundry_local.libSur Windows.
libfoundry_local.so sur Linux.
libfoundry_local.dylib sur macOS.

Déployez le runtime natif correspondant et les bibliothèques de dépendances en regard de votre exécutable ou dans le chemin de recherche de la bibliothèque de la plateforme. Conservez les versions de package restaurées ensemble. Ne mélangez pas de fichiers d’en-tête et de bibliothèques natives provenant de différentes versions.

Démarrage rapide

Remplacez le main.cpp de l’exemple par le code suivant pour initialiser le Kit de développement logiciel (SDK) et compter les modèles dans le catalogue :

#include <foundry_local/foundry_local_cpp.h>

#include <iostream>

using namespace foundry_local;

int main() {
    try {
        Manager manager{Configuration("app-name")};
        auto models = manager.GetCatalog().GetModels();
        std::cout << "Models available: " << models.size() << "\n";
    } catch (const Error& error) {
        std::cerr << "Foundry Local error [" << error.Code()
                  << "]: " << error.what() << "\n";
        return 1;
    }
    return 0;
}

L’exemple imprime Models available: suivi du nombre de modèles du catalogue. Il ne télécharge pas ou ne charge pas de modèle. Conservez le manager actif pendant que vous utilisez des objets de catalogue, de modèle ou de métadonnées obtenus à partir de celui-ci.

Référence : déclarations wrapper C++ pour Configuration, Manageret Catalog.

API principale

Le wrapper utilise le RAII (Resource Acquisition Is Initialization) pour libérer des handles natifs lorsque les objets quittent la portée.

API	Description
`Manager{Configuration("app-name")}`	Initialisez un gestionnaire avec un nom d’application.
`manager.GetCatalog()`	Obtenez le catalogue de modèles.
`catalog.GetModels()`	Répertoriez les modèles dans le catalogue.
`catalog.GetModel(alias)`	Recherchez un modèle par alias. Vérifiez le pointeur retourné avant de l’utiliser.
`model->Download()`	Téléchargez un modèle vers le cache local.
`model->Load()`	Chargez un modèle pour l’inférence.
`model->Unload()`	Décharger un modèle de la mémoire.
`ChatSession::ProcessRequest(request)`	Exécutez une requête de chat et renvoyez une réponse.

Référence de l’API et exemples

Utilisez l’en-tête public et les exemples maintenus pour les flux de travail d’inférence et d’API complets :

Commentaires

Cette page a-t-elle été utile ?

Dernière mise à jour : 2026-11-05

Informations de référence sur le SDK Foundry Local

Informations de référence sur le SDK C#

Installer des packages

configuration de Project

Démarrage rapide

Échantillons

Référence d’API

API de transcription audio native

Obtenir un client audio

Méthodes de transcription audio

Paramètres AudioClient

Exemple

Informations de référence sur le Kit de développement logiciel (SDK) JavaScript

Installer des packages

Démarrage rapide

Échantillons

Référence d’API

References

Informations de référence sur Python SDK

Installer des packages

Démarrage rapide

Échantillons

Paramétrage

API principale

API de complétions de chat native

API de transcription audio native

Référence SDK Rust

Installer des packages

Démarrage rapide

Échantillons

Paramétrage

API principale

API de complétions de chat native

API de transcription audio native

Référence du SDK C++

Prerequisites

Démarrage rapide

API principale

Référence de l’API et exemples

Commentaires

Ressources supplémentaires