Nota
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare ad accedere o modificare le directory.
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare a modificare le directory.
Foundry Local SDK consente di distribuire funzionalità di intelligenza artificiale nelle applicazioni in grado di usare modelli di intelligenza artificiale locali tramite un'API semplice e intuitiva. L'SDK astrae le complessità della gestione dei modelli di intelligenza artificiale e offre un'esperienza semplice per l'integrazione delle funzionalità di intelligenza artificiale locali nelle applicazioni. Questo riferimento documenta le implementazioni dell'SDK per C#, JavaScript, Python e Rust.
L'SDK non richiede l'installazione dell'interfaccia della riga di comando locale di Foundry nel computer degli utenti finali, consentendo di spedire le applicazioni senza passaggi di configurazione aggiuntivi per gli utenti. Le applicazioni sono autonome. I vantaggi aggiuntivi di Foundry Local SDK includono:
- Rilevamento e ottimizzazione dell'hardware: valutazione automatica delle funzionalità per GPU, NPU e CPU.
- Gestione del provider (Windows): download e registrazione automatica dei provider di esecuzione di RUNTIME ONNX appropriati (CUDA, Vitis, QNN, OpenVINO, TensorRT) in base alle funzionalità del dispositivo.
- Supporto Metal tramite WebGpu (macOS): supporto nativo per l'esecuzione di modelli su Apple Silicon con prestazioni ottimizzate.
- Acquisizione del modello: download facile da Foundry Model Catalog con controllo delle versioni, aggiornamenti e selezione automatica dei modelli ottimizzati per l'hardware con supporto di fallback.
- Runtime efficiente: aggiunge circa 20 MB alle dimensioni dell'app, viene eseguito su dispositivi da telefoni cellulari a desktop.
- Compatibilità dell'API OpenAI: facile integrazione con i modelli e gli strumenti OpenAI.
- Server REST facoltativo: eseguire Foundry Local come servizio locale accessibile da altre applicazioni.
Informazioni di riferimento su C# SDK
Installare i pacchetti
Se si sviluppa o si esegue la spedizione in Windows, selezionare la scheda Windows. Il pacchetto Windows si integra con il runtime Windows ML, che fornisce la stessa area di attacco API con un'ampiezza più ampia di accelerazione hardware.
dotnet add package Microsoft.AI.Foundry.Local.WinML
dotnet add package OpenAI
Gli esempi C# nel repository GitHub sono progetti preconfigurati. Se stai creando da zero, dovresti leggere il riferimento del Foundry Local SDK per ulteriori dettagli su come configurare il tuo progetto C# con Foundry Local.
Configurazione del progetto
I repository di esempio includono un .csproj file che gestisce automaticamente il rilevamento della piattaforma. Se si compila un progetto da zero, usare questa configurazione come riferimento:
<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.26100</TargetFramework>
<WindowsAppSDKSelfContained>false</WindowsAppSDKSelfContained>
<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>
<!-- Windows: WinML for hardware acceleration -->
<ItemGroup Condition="$([MSBuild]::IsOSPlatform('Windows'))">
<PackageReference Include="Microsoft.AI.Foundry.Local.WinML" />
</ItemGroup>
<!-- Non-Windows: standard SDK -->
<ItemGroup Condition="!$([MSBuild]::IsOSPlatform('Windows'))">
<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>
La tabella seguente illustra le impostazioni principali del progetto:
| Impostazione | Descrizione |
|---|---|
TargetFramework |
Su Windows, i target net9.0-windows10.0.26100 per l'accelerazione hardware di WinML. Su altre piattaforme, i target sono net9.0. |
WindowsAppSDKSelfContained |
Impostare su false per usare il SDK per app di Windows installato dal sistema anziché creare un bundle. |
WindowsPackageType |
Impostare None su per compilare come applicazione desktop non confezionata (nessun pacchetto MSIX). |
EnableCoreMrtTooling |
Impostare false per disabilitare la strumentazione delle risorse di MRT Core, che non è necessaria per le app console. |
RuntimeIdentifier |
L'impostazione di default è l'identificatore di runtime dell'SDK in uso, garantendo la selezione dei file binari corretti per la piattaforma. |
Microsoft.AI.Foundry.Local.WinML |
Pacchetto esclusivo per Windows che utilizza WinML per l'accelerazione hardware e la gestione automatica dei provider di esecuzione. |
Microsoft.AI.Foundry.Local |
Pacchetto multipiattaforma per macOS, Linux e Windows senza WinML. |
Microsoft.ML.OnnxRuntime.Gpu / OnnxRuntimeGenAI.Cuda |
Pacchetti di supporto GPU Linux per l'hardware abilitato per CUDA. |
Avvio rapido
Usare questo frammento di codice per verificare che l'SDK possa inizializzare e accedere al catalogo del modello locale.
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()}");
In questo esempio viene stampato il numero di modelli disponibili per l'hardware.
Esempi
- Per le applicazioni di esempio che illustrano come usare l'SDK C# locale di Foundry, vedere Foundry Local C# SDK Samples GitHub repository.
Informazioni di riferimento sulle API
- Per altre informazioni su Foundry Local C# SDK, vedere Foundry Local C# SDK API Reference (Informazioni di riferimento sull'API C# locale di Foundry).
API di trascrizione audio nativa
C# SDK include un client audio nativo per la trascrizione di file audio su dispositivo tramite i modelli Whisper. L'inferenza viene eseguita in-process senza bisogno del server REST.
Ottenere un client audio
Dopo aver caricato un modello Whisper, ottenere un client audio:
var audioClient = await model.GetAudioClientAsync();
Metodi di trascrizione audio
| metodo | Signature | Descrizione |
|---|---|---|
TranscribeAudioStreamingAsync() |
(string audioFilePath, CancellationToken ct) => IAsyncEnumerable<TranscriptionChunk> |
Trasmette i risultati della trascrizione in segmenti. Ogni blocco ha una Text proprietà . |
Impostazioni di AudioClient
| Proprietà | Tipo | Descrizione |
|---|---|---|
Language |
string |
Codice linguistico ISO 639-1 (ad esempio, "en"). Migliora l'accuratezza. |
Temperature |
float |
Temperatura di campionamento (0,0-1,0). I valori inferiori sono più deterministici. |
Esempio
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);
}
Riferimenti:
Informazioni di riferimento su JavaScript SDK
Installare i pacchetti
Se si sviluppa o si esegue la spedizione in Windows, selezionare la scheda Windows. Il pacchetto Windows si integra con il runtime Windows ML, che fornisce la stessa area di attacco API con un'ampiezza più ampia di accelerazione hardware.
npm install foundry-local-sdk-winml openai
Avvio rapido
Usare questo frammento di codice per verificare che l'SDK possa inizializzare e accedere al catalogo del modello locale.
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}`);
}
In questo esempio viene restituito l'elenco dei modelli disponibili per l'hardware.
Esempi
- Per applicazioni di esempio che illustrano come usare il Foundry Local JavaScript SDK, consultare l'archivio GitHub dedicato agli esempi del Foundry Local JavaScript SDK.
Informazioni di riferimento sulle API
- Per altre informazioni su Foundry Local JavaScript SDK, vedere Foundry Local JavaScript SDK API Reference (Informazioni di riferimento sull'API JavaScript SDK locale di Foundry).
References
Informazioni di riferimento su Python SDK
Installare i pacchetti
Se si sviluppa o si esegue la spedizione in Windows, selezionare la scheda Windows. Il pacchetto Windows si integra con il runtime Windows ML, che fornisce la stessa area di attacco API con un'ampiezza più ampia di accelerazione hardware.
pip install foundry-local-sdk-winml openai
Avvio rapido
Usare questo frammento di codice per verificare che l'SDK possa inizializzare e accedere al catalogo del modello locale.
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())
In questo esempio viene stampato il numero di modelli disponibili per l'hardware.
Esempi
- Per applicazioni di esempio che illustrano come usare Foundry Local Python SDK, vedere Foundry Local SDK Samples GitHub repository.
Configurazione
La Configuration classe consente di personalizzare il comportamento dell'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"},
)
| Parametro | Tipo | Descrizione |
|---|---|---|
app_name |
str |
Nome dell'applicazione. |
log_level |
str |
Livello di registrazione (ad esempio, "info", "debug"). |
model_cache_dir |
str |
Directory per i modelli memorizzati nella cache. |
web |
dict |
Configurazione del servizio Web con urls chiave. |
API di base
| metodo | Descrizione |
|---|---|
FoundryLocalManager.initialize(config) |
Inizializzare il gestore singleton con un oggetto Configuration. |
FoundryLocalManager.instance |
Accedere all'istanza di gestione inizializzata. |
manager.catalog.list_models() |
Elencare tutti i modelli disponibili nel catalogo. |
manager.catalog.get_model(alias) |
Ottieni un modello tramite alias. |
manager.catalog.get_cached_models() |
Elencare i modelli nella cache locale. |
manager.catalog.get_loaded_models() |
Elencare i modelli attualmente caricati. |
model.download(progress_callback) |
Scaricare il modello (ignora se memorizzato nella cache). |
model.load() |
Caricare il modello per l'inferenza. |
model.unload() |
Scaricare il modello. |
model.is_cached |
Controllare se il modello viene memorizzato nella cache in locale. |
model.is_loaded |
Controllare se il modello è caricato. |
API di completamento della chat nativa
Dopo aver caricato un modello, ottenere un client di chat:
client = model.get_chat_client()
| metodo | Descrizione |
|---|---|
client.complete_chat(messages) |
Generare una risposta di chat completa. |
client.complete_streaming_chat(messages) |
Blocchi di risposta di chat di flusso. |
API di trascrizione audio nativa
Dopo aver caricato un modello Whisper, ottenere un client audio:
audio_client = model.get_audio_client()
| metodo | Descrizione |
|---|---|
audio_client.transcribe(file_path) |
Trascrivere un file audio. Restituisce un oggetto con una text proprietà . |
Riferimenti:
Informazioni di riferimento su Rust SDK
Installare i pacchetti
Se si sviluppa o si esegue la spedizione in Windows, selezionare la scheda Windows. Il pacchetto Windows si integra con il runtime Windows ML, che fornisce la stessa area di attacco API con un'ampiezza più ampia di accelerazione hardware.
cargo add foundry-local-sdk --features winml
cargo add tokio --features full
cargo add tokio-stream anyhow
Avvio rapido
Usare questo frammento di codice per verificare che l'SDK possa inizializzare e accedere al catalogo del modello locale.
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(())
}
In questo esempio viene stampato il numero di modelli disponibili per l'hardware.
Esempi
- Per applicazioni di esempio che illustrano come usare Foundry Local Rust SDK, vedere Foundry Local SDK Samples GitHub repository.
Configurazione
Lo FoundryLocalConfig struct consente di personalizzare il comportamento dell'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 di base
| metodo | Descrizione |
|---|---|
FoundryLocalManager::create(config) |
Creare un nuovo gestore con un oggetto FoundryLocalConfig. |
manager.catalog().get_models().await |
Elencare tutti i modelli disponibili. |
manager.catalog().get_model(alias).await |
Ottieni un modello tramite alias. |
manager.catalog().get_cached_models().await |
Elencare i modelli nella cache locale. |
manager.catalog().get_loaded_models().await |
Elencare i modelli attualmente caricati. |
model.download(callback).await |
Scaricare il modello (ignora se memorizzato nella cache). |
model.load().await |
Caricare il modello per l'inferenza. |
model.unload().await |
Scaricare il modello. |
API di completamento della chat nativa
Dopo aver caricato un modello, creare un client di chat con impostazioni facoltative:
let client = model.create_chat_client()
.temperature(0.7)
.max_tokens(256);
| metodo | Descrizione |
|---|---|
client.complete_chat(&messages, tools).await |
Generare una risposta di chat completa. |
client.complete_streaming_chat(&messages, tools).await |
Blocchi di risposta di chat di flusso. |
Tipi di messaggio: ChatCompletionRequestSystemMessage, ChatCompletionRequestUserMessage, ChatCompletionRequestMessage.
API di trascrizione audio nativa
Dopo aver caricato un modello Whisper, creare un client audio:
let audio_client = model.create_audio_client();
| metodo | Descrizione |
|---|---|
audio_client.transcribe(file_path).await |
Trascrivere un file audio. Restituisce un oggetto con un text campo. |
Riferimenti: