Lokalne odniesienia do zestawu SDK Foundry

Dokumentacja zestawu SDK języka Python

Wymagania wstępne

• Zainstaluj program Foundry Local i upewnij się, że polecenie foundry jest dostępne w twoim PATH.
• Użyj języka Python w wersji 3.9 lub nowszej.

Instalacja

Zainstaluj pakiet języka Python:

pip install foundry-local-sdk

Szybki start

Użyj tego fragmentu kodu, aby sprawdzić, czy zestaw SDK może uruchomić usługę i uzyskać dostęp do katalogu lokalnego.

from foundry_local import FoundryLocalManager

manager = FoundryLocalManager()
manager.start_service()

catalog = manager.list_catalog_models()
print(f"Catalog models available: {len(catalog)}")

W tym przykładzie jest wyświetlany numer inny niż zero, gdy usługa jest uruchomiona, a katalog jest dostępny.

Dokumentacja:

• Integracja z zestawami SDK wnioskowania

klasa FoundryLocalManager

Klasa FoundryLocalManager udostępnia metody zarządzania modelami, pamięcią podręczną i lokalną usługą Foundry.

Inicjalizacja

from foundry_local import FoundryLocalManager

# Initialize and optionally bootstrap with a model
manager = FoundryLocalManager(alias_or_model_id=None, bootstrap=True)

• alias_or_model_id: (opcjonalnie) Alias lub identyfikator modelu do pobrania i załadowania podczas uruchamiania systemu.
• bootstrap: (wartość domyślna True) Jeśli wartość True, uruchomi usługę, jeśli nie jest uruchomiona i załaduje model, jeśli zostanie podany.

Uwaga dotycząca aliasów

Wiele metod opisanych w tym dokumencie ma parametr alias_or_model_id w podpisie. Możesz przekazać do metody alias lub identyfikator modelu jako wartość. Użycie aliasu spowoduje:

• Wybierz najlepszy model dla dostępnego sprzętu. Jeśli na przykład procesor GPU Nvidia CUDA jest dostępny, narzędzie Foundry Local wybiera model CUDA. Jeśli dostępny jest obsługiwany NPU, Foundry Local wybiera model NPU.
• Umożliwia używanie krótszej nazwy bez konieczności zapamiętania identyfikatora modelu.

Zarządzanie usługami

Zarządzanie katalogami

Zarządzanie pamięcią podręczną

Zarządzanie modelami

FoundryModelInfo

Metody list_catalog_models(), list_cached_models()i list_loaded_models() zwracają listę FoundryModelInfo obiektów. Aby dokładniej uściślić listę, możesz użyć informacji zawartych w tym obiekcie. Możesz też uzyskać informacje dotyczące modelu bezpośrednio przez wywołanie get_model_info(alias_or_model_id) metody .

Te obiekty zawierają następujące pola:

Dostawcy wykonywania

Jeden z:

• CPUExecutionProvider - Wykonywanie oparte na procesorze
• CUDAExecutionProvider - Wykonywanie procesora GPU NVIDIA CUDA
• WebGpuExecutionProvider - Wykonywanie protokołu WebGPU
• QNNExecutionProvider - Przetwarzanie sieci neuronowej Qualcomm (NPU)
• OpenVINOExecutionProvider - Wykonanie Intel OpenVINO
• NvTensorRTRTXExecutionProvider - Wykonywanie NVIDIA TensorRT
• VitisAIExecutionProvider — Wykonywanie sztucznej inteligencji przez oprogramowanie AMD Vitis

Przykładowe użycie

Poniższy kod pokazuje, jak używać FoundryLocalManager klasy do zarządzania modelami i interakcji z lokalną usługą Foundry.

from foundry_local import FoundryLocalManager

# By using an alias, the most suitable model will be selected
# to your end-user's device.
alias = "qwen2.5-0.5b"

# Create a FoundryLocalManager instance. This will start the Foundry.
manager = FoundryLocalManager()

# List available models in the catalog
catalog = manager.list_catalog_models()
print(f"Available models in the catalog: {catalog}")

# Download and load a model
model_info = manager.download_model(alias)
model_info = manager.load_model(alias)
print(f"Model info: {model_info}")

# List models in cache
local_models = manager.list_cached_models()
print(f"Models in cache: {local_models}")

# List loaded models
loaded = manager.list_loaded_models()
print(f"Models running in the service: {loaded}")

# Unload a model
manager.unload_model(alias)

W tym przykładzie wymieniono modele, pobrano i załadowano jeden model, a następnie go zwolniono.

Dokumentacja:

• Integracja z zestawami SDK wnioskowania

Integracja z zestawem OpenAI SDK

Zainstaluj pakiet OpenAI:

pip install openai

Poniższy kod przedstawia sposób integracji FoundryLocalManager z zestawem OpenAI SDK w celu interakcji z modelem lokalnym.

import openai
from foundry_local import FoundryLocalManager

# By using an alias, the most suitable model will be downloaded
# to your end-user's device.
alias = "qwen2.5-0.5b"

# Create a FoundryLocalManager instance. This will start the Foundry
# Local service if it is not already running and load the specified model.
manager = FoundryLocalManager(alias)

# The remaining code uses the OpenAI Python SDK to interact with the local model.

# Configure the client to use the local Foundry service
client = openai.OpenAI(
    base_url=manager.endpoint,
    api_key=manager.api_key  # API key is not required for local usage
)

# Set the model to use and generate a streaming response
stream = client.chat.completions.create(
    model=manager.get_model_info(alias).id,
    messages=[{"role": "user", "content": "Why is the sky blue?"}],
    stream=True
)

# Print the streaming response
for chunk in stream:
    if chunk.choices[0].delta.content is not None:
        print(chunk.choices[0].delta.content, end="", flush=True)

W tym przykładzie model lokalny przesyła odpowiedź strumieniową na zakończenie czatu.

Dokumentacja:

• Integracja z zestawami SDK wnioskowania

Dokumentacja zestawu SDK języka JavaScript

Wymagania wstępne

• Zainstaluj program Foundry Local i upewnij się, że polecenie foundry jest dostępne na PATH.

Instalacja

Zainstaluj pakiet z narzędzia npm:

npm install foundry-local-sdk

Szybki start

Użyj tego fragmentu kodu, aby sprawdzić, czy zestaw SDK może uruchomić usługę i uzyskać dostęp do katalogu lokalnego.

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

const manager = new FoundryLocalManager();

await manager.startService();
const catalogModels = await manager.listCatalogModels();

console.log(`Catalog models available: ${catalogModels.length}`);

W tym przykładzie jest wyświetlany numer inny niż zero, gdy usługa jest uruchomiona, a katalog jest dostępny.

Dokumentacja:

• Integracja z zestawami SDK wnioskowania

klasa FoundryLocalManager

Klasa FoundryLocalManager umożliwia zarządzanie modelami, kontrolowanie pamięci podręcznej i interakcję z lokalną usługą Foundry w środowiskach przeglądarki i Node.js.

Inicjalizacja

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

const foundryLocalManager = new FoundryLocalManager();

Dostępne opcje:

• host: podstawowy adres URL usługi lokalnej Foundry
• fetch: (opcjonalnie) Niestandardowa implementacja pobierania dla środowisk, takich jak Node.js

Uwaga dotycząca aliasów

Wiele metod opisanych w tym dokumencie ma parametr aliasOrModelId w podpisie. Możesz przekazać do metody alias lub identyfikator modelu jako wartość. Użycie aliasu spowoduje:

• Wybierz najlepszy model dla dostępnego sprzętu. Jeśli na przykład procesor GPU Nvidia CUDA jest dostępny, narzędzie Foundry Local wybiera model CUDA. Jeśli dostępny jest obsługiwany NPU, Foundry Local wybiera model NPU.
• Umożliwia używanie krótszej nazwy bez konieczności zapamiętania identyfikatora modelu.

Zarządzanie usługami

Zarządzanie katalogami

Zarządzanie pamięcią podręczną

Zarządzanie modelami

Przykładowe użycie

Poniższy kod pokazuje, jak używać FoundryLocalManager klasy do zarządzania modelami i interakcji z lokalną usługą Foundry.

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

// By using an alias, the most suitable model will be downloaded
// to your end-user's device.
// TIP: You can find a list of available models by running the
// following command in your terminal: `foundry model list`.
const alias = "qwen2.5-0.5b";

const manager = new FoundryLocalManager();

// Initialize the SDK and optionally load a model
const modelInfo = await manager.init(alias);
console.log("Model Info:", modelInfo);

// Check if the service is running
const isRunning = await manager.isServiceRunning();
console.log(`Service running: ${isRunning}`);

// List available models in the catalog
const catalog = await manager.listCatalogModels();

// Download and load a model
await manager.downloadModel(alias);
await manager.loadModel(alias);

// List models in cache
const localModels = await manager.listCachedModels();

// List loaded models
const loaded = await manager.listLoadedModels();

// Unload a model
await manager.unloadModel(alias);

Ten przykład pobiera i ładuje model, a następnie wyświetla listę buforowanych i załadowanych modeli.

Dokumentacja:

• Integracja z zestawami SDK wnioskowania

Integracja z klientem OpenAI

Zainstaluj pakiet OpenAI:

npm install openai

Poniższy kod pokazuje, jak zintegrować program FoundryLocalManager z klientem OpenAI w celu interakcji z modelem lokalnym.

import { OpenAI } from "openai";
import { FoundryLocalManager } from "foundry-local-sdk";

// By using an alias, the most suitable model will be downloaded
// to your end-user's device.
// TIP: You can find a list of available models by running the
// following command in your terminal: `foundry model list`.
const alias = "qwen2.5-0.5b";

// Create a FoundryLocalManager instance. This will start the Foundry
// Local service if it is not already running.
const foundryLocalManager = new FoundryLocalManager();

// Initialize the manager with a model. This will download the model
// if it is not already present on the user's device.
const modelInfo = await foundryLocalManager.init(alias);
console.log("Model Info:", modelInfo);

const openai = new OpenAI({
  baseURL: foundryLocalManager.endpoint,
  apiKey: foundryLocalManager.apiKey,
});

async function streamCompletion() {
  const stream = await openai.chat.completions.create({
    model: modelInfo.id,
    messages: [{ role: "user", content: "What is the golden ratio?" }],
    stream: true,
  });

  for await (const chunk of stream) {
    if (chunk.choices[0]?.delta?.content) {
      process.stdout.write(chunk.choices[0].delta.content);
    }
  }
}

streamCompletion();

W tym przykładzie przesyłana strumieniowo odpowiedź na zakończenie czatu z modelu lokalnego.

Dokumentacja:

• Integracja z zestawami SDK wnioskowania

Użycie przeglądarki

Zestaw SDK zawiera wersję zgodną z przeglądarką, w której należy ręcznie określić adres URL hosta:

import { FoundryLocalManager } from "foundry-local-sdk/browser";

// Specify the service URL
// Run the Foundry Local service using the CLI: `foundry service start`
// and use the URL from the CLI output
const host = "HOST";

const manager = new FoundryLocalManager({ host });

// Note: The `init`, `isServiceRunning`, and `startService` methods
// are not available in the browser version

Przykładowe użycie

import { FoundryLocalManager } from "foundry-local-sdk/browser";

// Specify the service URL
// Run the Foundry Local service using the CLI: `foundry service start`
// and use the URL from the CLI output
const host = "HOST";

const manager = new FoundryLocalManager({ host });

const alias = "qwen2.5-0.5b";

// Get all available models
const catalog = await manager.listCatalogModels();
console.log("Available models in catalog:", catalog);

// Download and load a specific model
await manager.downloadModel(alias);
await manager.loadModel(alias);

// View models in your local cache
const localModels = await manager.listCachedModels();
console.log("Cached models:", localModels);

// Check which models are currently loaded
const loaded = await manager.listLoadedModels();
console.log("Loaded models in inference service:", loaded);

// Unload a model when finished
await manager.unloadModel(alias);

Dokumentacja:

• Integracja z zestawami SDK wnioskowania

Dokumentacja zestawu SDK języka C#

Przewodnik konfiguracji projektu

Istnieją dwa pakiety NuGet dla lokalnego zestawu SDK usługi Foundry — winML i pakiet międzyplatformowy — które mają tę samą powierzchnię interfejsu API, ale są zoptymalizowane pod kątem różnych platform:

• Windows: używa Microsoft.AI.Foundry.Local.WinML pakietu specyficznego dla aplikacji systemu Windows, który korzysta z platformy Windows Machine Learning (WinML).
• Międzyplatformowe: używa Microsoft.AI.Foundry.Local pakietu, który może być używany dla aplikacji międzyplatformowych (Windows, Linux, macOS).

W zależności od platformy docelowej wykonaj następujące instrukcje, aby utworzyć nową aplikację języka C# i dodać niezbędne zależności:

Użyj polecenia Foundry Local w projekcie języka C#, postępując zgodnie z tymi instrukcjami specyficznymi dla systemu Windows lub międzyplatformowymi (macOS/Linux/Windows):

Szybki start

Użyj tego fragmentu kodu, aby sprawdzić, czy zestaw SDK może zainicjować katalog modeli lokalnych i uzyskać do niego dostęp.

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()}");

W tym przykładzie wyświetlana jest liczba modeli dostępnych dla twojego sprzętu.

Dokumentacja:

• Integracja z zestawami SDK wnioskowania

Przeprojektowanie

Aby zwiększyć możliwość dostarczania aplikacji przy użyciu sztucznej inteligencji na urządzeniu, wprowadzono istotne zmiany w architekturze zestawu SDK języka C# w wersji 0.8.0 i nowszych wersjach. W tej sekcji opisano kluczowe zmiany ułatwiające migrowanie aplikacji do najnowszej wersji zestawu SDK.

Na poniższym diagramie pokazano, jak poprzednia architektura — dla wersji wcześniejszych niż 0.8.0 — w dużym stopniu polegała na używaniu serwera internetowego REST do zarządzania modelami i wnioskowaniem, takimi jak kończenia czatów:

Zestaw SDK użyje zdalnego wywołania procedury (RPC), aby znaleźć lokalny CLI Foundry na maszynie, uruchomić serwer internetowy, a następnie komunikować się z nim za pośrednictwem protokołu HTTP. Ta architektura miała kilka ograniczeń, w tym:

• Złożoność zarządzania cyklem życia serwera internetowego.
• Trudne wdrożenie: użytkownicy końcowi musieli zainstalować lokalny interfejs wiersza polecenia usługi Foundry na swoich maszynach i aplikacji.
• Zarządzanie wersjami interfejsu wiersza polecenia i zestawu SDK może prowadzić do problemów ze zgodnością.

Aby rozwiązać te problemy, przeprojektowana architektura w wersji 0.8.0 i nowszej korzysta z bardziej usprawnionego podejścia. Nowa architektura jest następująca:

W tej nowej architekturze:

• Aplikacja jest samodzielna. Nie wymaga oddzielnego zainstalowania lokalnego interfejsu wiersza polecenia Foundry na maszynie użytkownika końcowego, co ułatwia wdrażanie aplikacji.
• Serwer internetowy REST jest opcjonalny. Nadal możesz użyć serwera internetowego, jeśli chcesz zintegrować się z innymi narzędziami komunikujących się za pośrednictwem protokołu HTTP. Aby uzyskać szczegółowe informacje na temat korzystania z tej funkcji, przeczytaj Używanie uzupełniania czatów za pośrednictwem serwera REST z lokalną usługą Foundry .
• Zestaw SDK zapewnia natywną obsługę uzupełniania czatów i transkrypcji audio, umożliwiając tworzenie aplikacji konwersacyjnych sztucznej inteligencji z mniejszą liczbą zależności. Aby uzyskać szczegółowe informacje na temat korzystania z tej funkcji, przeczytaj Używanie interfejsu API natywnych uzupełniania czatów lokalnych w Foundry.
• Na urządzeniach z systemem Windows można użyć kompilacji uczenia maszynowego z systemem Windows, która obsługuje przyspieszanie sprzętowe dla modeli na urządzeniu, ściągając odpowiednie środowisko uruchomieniowe i sterowniki.

Zmiany w interfejsie API

Wersja 0.8.0 i późniejsze udostępniają bardziej obiektowo zorientowany i komponowalny interfejs API. Głównym punktem wejścia pozostaje klasa FoundryLocalManager, ale zamiast stanowić płaski zestaw metod operujących przez statyczne wywołania do bezstanowego interfejsu API HTTP, zestaw SDK teraz udostępnia metody w instancji FoundryLocalManager, która zachowuje informacje o stanie usługi i modelach.

Interfejs API umożliwia, aby Foundry Local był bardziej konfigurowalny w zakresie serwera WWW, rejestrowania, lokalizacji pamięci podręcznej i wyboru wariantu modelu. Na przykład Configuration klasa umożliwia skonfigurowanie nazwy aplikacji, poziomu rejestrowania, adresów URL serwera internetowego i katalogów dla danych aplikacji, pamięci podręcznej modelu i dzienników:

var config = new Configuration
{
    AppName = "app-name",
    LogLevel = Microsoft.AI.Foundry.Local.LogLevel.Information,
    Web = new Configuration.WebService
    {
        Urls = "http://127.0.0.1:55588"
    },
    AppDataDir = "./foundry_local_data",
    ModelCacheDir = "{AppDataDir}/model_cache",
    LogsDir = "{AppDataDir}/logs"
};

Dokumentacja:

• Integracja z zestawami SDK wnioskowania

W poprzedniej wersji lokalnego zestawu SDK języka C# usługi Foundry nie można skonfigurować tych ustawień bezpośrednio za pomocą zestawu SDK, co ogranicza możliwość dostosowywania zachowania usługi.

Zmniejsz rozmiar pakietu aplikacji

Lokalny SDK Foundry pobiera pakiet NuGet jako zależność. Pakiet Microsoft.ML.OnnxRuntime.Foundry zawiera pakiet środowiska uruchomieniowego wnioskowania, który jest zestawem bibliotek wymaganych do wydajnego wnioskowania na określonych urządzeniach sprzętowych dostawcy. Pakiet środowiska uruchomieniowego wnioskowania zawiera następujące składniki:

• Biblioteka środowiska uruchomieniowego ONNX: podstawowy aparat wnioskowania (onnxruntime.dll).
• Biblioteka ONNX Runtime Execution Provider (EP). Zaplecze specyficzne dla sprzętu w środowisku uruchomieniowym ONNX, które optymalizuje i wykonuje części modelu uczenia maszynowego przy użyciu akceleratora sprzętowego. Przykład:
  • CUDA EP: onnxruntime_providers_cuda.dll
  • QNN EP: onnxruntime_providers_qnn.dll
• Biblioteki niezależnego dostawcy sprzętu (IHV). Przykład:
  • WebGPU: zależności DirectX (dxcompiler.dll, dxil.dll)
  • QNN: Zależności Qualcomm QNN (QnnSystem.dll, itp.)

W poniższej tabeli podsumowano, jakie biblioteki EP i IHV są powiązane z aplikacją i jakie biblioteki WinML będą pobierane/instalowane w czasie wykonywania:

We wszystkich platformach i architekturach wymagany jest CPU EP. Biblioteki Protokołu WebGPU EP i IHV są małe (na przykład protokół WebGPU dodaje tylko ~7 MB do pakietu aplikacji) i są wymagane w systemach Windows i macOS. Jednak adresy EPS CUDA i QNN są duże (na przykład CUDA dodaje ~1 GB do pakietu aplikacji), dlatego zalecamy wykluczenie tych adresów EPS z pakietu aplikacji. WinML pobierze i zainstaluje CUDA oraz QNN w czasie działania programu, jeśli ten użytkownik końcowy ma zgodny sprzęt.

Aby zmniejszyć rozmiar pakietu aplikacji, możesz utworzyć ExcludeExtraLibs.props plik w katalogu projektu z następującą zawartością, która wyklucza biblioteki CUDA i QNN EP i IHV podczas publikowania aplikacji:

<Project>
  <!-- we want to ensure we're using the onnxruntime libraries from Foundry Local Core so 
  we delete the WindowsAppSdk versions once they're unzipped. -->
  <Target Name="ExcludeOnnxRuntimeLibs" AfterTargets="ExtractMicrosoftWindowsAppSDKMsixFiles">
    <Delete Files="$(MicrosoftWindowsAppSDKMsixContent)\onnxruntime.dll"/>
    <Delete Files="$(MicrosoftWindowsAppSDKMsixContent)\onnxruntime_providers_shared.dll"/>
    <Message Importance="Normal" Text="Deleted onnxruntime libraries from $(MicrosoftWindowsAppSDKMsixContent)." />
  </Target>

  <!-- Remove CUDA EP and IHV libraries on Windows x64 -->
  <Target Name="ExcludeCudaLibs" Condition="'$(RuntimeIdentifier)'=='win-x64'" AfterTargets="ResolvePackageAssets">
    <ItemGroup>
      <!-- match onnxruntime*cuda.* (we're matching %(Filename) which excludes the extension) -->
      <NativeCopyLocalItems Remove="@(NativeCopyLocalItems)"
                            Condition="$([System.Text.RegularExpressions.Regex]::IsMatch('%(Filename)', 
                                      '^onnxruntime.*cuda.*', RegexOptions.IgnoreCase))" />
    </ItemGroup>
    <Message Importance="Normal" Text="Excluded onnxruntime CUDA libraries from package." />
  </Target>

  <!-- Remove QNN EP and IHV libraries on Windows arm64 -->
  <Target Name="ExcludeQnnLibs" Condition="'$(RuntimeIdentifier)'=='win-arm64'" AfterTargets="ResolvePackageAssets">
    <ItemGroup>
      <NativeCopyLocalItems Remove="@(NativeCopyLocalItems)"
                            Condition="$([System.Text.RegularExpressions.Regex]::IsMatch('%(Filename)%(Extension)', 
                                      '^QNN.*\.dll', RegexOptions.IgnoreCase))" />
      <NativeCopyLocalItems Remove="@(NativeCopyLocalItems)"
                            Condition="$([System.Text.RegularExpressions.Regex]::IsMatch('%(Filename)', 
                                      '^libQNNhtp.*', RegexOptions.IgnoreCase))" />
      <NativeCopyLocalItems Remove="@(NativeCopyLocalItems)"
                            Condition="'%(FileName)%(Extension)' == 'onnxruntime_providers_qnn.dll'" />
    </ItemGroup>
    <Message Importance="Normal" Text="Excluded onnxruntime QNN libraries from package." />
  </Target>

  <!-- need to manually copy on linux-x64 due to the nuget packages not having the correct props file setup -->
  <ItemGroup Condition="'$(RuntimeIdentifier)' == 'linux-x64'">
    <!-- 'Update' as the Core package will add these dependencies, but we want to be explicit about the version -->
    <PackageReference Update="Microsoft.ML.OnnxRuntime.Gpu" />
    <PackageReference Update="Microsoft.ML.OnnxRuntimeGenAI.Cuda" />
    <OrtNativeLibs Include="$(NuGetPackageRoot)microsoft.ml.onnxruntime.gpu.linux/$(OnnxRuntimeVersion)/runtimes/$(RuntimeIdentifier)/native/*" />
    <OrtGenAINativeLibs Include="$(NuGetPackageRoot)microsoft.ml.onnxruntimegenai.cuda/$(OnnxRuntimeGenAIVersion)/runtimes/$(RuntimeIdentifier)/native/*" />
  </ItemGroup>

  <Target Name="CopyOrtNativeLibs" AfterTargets="Build" Condition=" '$(RuntimeIdentifier)' == 'linux-x64'">
    <Copy SourceFiles="@(OrtNativeLibs)" DestinationFolder="$(OutputPath)"></Copy>
    <Copy SourceFiles="@(OrtGenAINativeLibs)" DestinationFolder="$(OutputPath)"></Copy>
  </Target>
</Project>

W pliku projektu (.csproj) dodaj następujący wiersz, aby zaimportować ExcludeExtraLibs.props plik:

<!-- other project file content -->
  
<Import Project="ExcludeExtraLibs.props" />

Windows: zależności CUDA

CUDA EP jest ściągany do aplikacji systemu Linux za pośrednictwem Microsoft.ML.OnnxRuntime.Foundry, ale nie uwzględniamy bibliotek IHV. Jeśli chcesz umożliwić użytkownikom końcowym korzystającym z urządzeń z obsługą CUDA odnieść korzyści z wyższej wydajności, musisz dodać następujące biblioteki CUDA IHV do swojej aplikacji:

• CUBLAS v12.8.4 (pobierz z witryny NVIDIA Developer)
  • cublas64_12.dll
  • cublasLt64_12.dll
• CUDA RT w wersji 12.8.90 (pobierz z witryny NVIDIA Developer)
  • cudart64_12.dll
• CUDNN v9.8.0 (pobierz z witryny NVIDIA Developer)
  • cudnn_graph64_9.dll
  • cudnn_ops64_9.dll
  • cudnn64_9.dll
• CUDA FFT v11.3.3.83 (pobierz z witryny NVIDIA Developer)
  • cufft64_11.dll

Samples

• Aby zapoznać się z przykładowymi aplikacjami, które pokazują, jak używać lokalnego zestawu SDK języka C# usługi Foundry, zobacz repozytorium GitHub przykłady lokalnego zestawu SDK języka C# rozwiązania Foundry.

Odniesienie do API

• Aby uzyskać więcej informacji na temat lokalnego zestawu SDK języka C# usługi Foundry, zobacz Dokumentacja lokalnego interfejsu API zestawu SDK języka C# w języku Foundry.

Dokumentacja zestawu Rust SDK

Zestaw Rust SDK for Foundry Local umożliwia zarządzanie modelami, kontrolowanie pamięci podręcznej i interakcję z lokalną usługą Foundry.

Wymagania wstępne

• Zainstaluj program Foundry Local i upewnij się, że polecenie foundry jest dostępne na PATH.
• Użyj wersji Rust 1.70.0 lub nowszej.

Instalacja

Aby użyć lokalnego zestawu SDK Rust Foundry, dodaj następujące do elementu Cargo.toml.

[dependencies]
foundry-local = "0.1.0"

Alternatywnie możesz dodać skrzynię Foundry Local przy użyciu polecenia cargo.

cargo add foundry-local

Szybki start

Użyj tego fragmentu kodu, aby sprawdzić, czy zestaw SDK może uruchomić usługę i odczytać katalog lokalny.

use anyhow::Result;
use foundry_local::FoundryLocalManager;

#[tokio::main]
async fn main() -> Result<()> {
  let mut manager = FoundryLocalManager::builder().bootstrap(true).build().await?;

  let models = manager.list_catalog_models().await?;
  println!("Catalog models available: {}", models.len());

  Ok(())
}

W tym przykładzie jest wyświetlany numer inny niż zero, gdy usługa jest uruchomiona, a katalog jest dostępny.

Dokumentacja:

• Dokumentacja lokalna usługi Foundry
• dokumentacja skrzynek foundry-local

FoundryLocalManager

Menedżer operacji lokalnego zestawu SDK usługi Foundry.

Pola formularza

• service_uri: Option<String> — identyfikator URI usługi Foundry.
• client: Option<HttpClient> — klient HTTP dla żądań interfejsu API.
• catalog_list: Option<Vec<FoundryModelInfo>> — buforowana lista modeli wykazu.
• catalog_dict: Option<HashMap<String, FoundryModelInfo>> — Zbuforowany słownik modeli katalogu.
• timeout: Option<u64> — opcjonalny limit czasu klienta HTTP.

Metody

• pub fn builder() -> FoundryLocalManagerBuilder
  Utwórz nowego konstruktora dla elementu FoundryLocalManager.

• pub fn service_uri(&self) -> Result<&str>
  Pobierz identyfikator URI usługi.
  Zwraca: URI usługi Foundry.

• fn client(&self) -> Result<&HttpClient>
  Pobierz wystąpienie klienta HTTP.
  Zwraca: Klient HTTP.

• pub fn endpoint(&self) -> Result<String>
  Pobierz punkt końcowy dla usługi.
  Zwraca: Adres URL punktu końcowego.

• pub fn api_key(&self) -> String
  Pobierz klucz interfejsu API na potrzeby uwierzytelniania.
  Zwraca: Klucz API.

• pub fn is_service_running(&mut self) -> bool
  Sprawdź, czy usługa jest uruchomiona, i ustaw identyfikator URI usługi, jeśli zostanie znaleziony.
  Zwraca:true jeśli jest uruchomiona, false w przeciwnym razie.

• pub fn start_service(&mut self) -> Result<()>
  Uruchom usługę lokalną Foundry.

• pub async fn list_catalog_models(&mut self) -> Result<&Vec<FoundryModelInfo>>
  Pobierz listę dostępnych modeli w wykazie.

• pub fn refresh_catalog(&mut self)
  Odśwież pamięć podręczną katalogu.

• pub async fn get_model_info(&mut self, alias_or_model_id: &str, raise_on_not_found: bool) -> Result<FoundryModelInfo>
  Uzyskaj informacje o modelu według aliasu lub identyfikatora.
  argumenty:

  • alias_or_model_id: alias lub identyfikator modelu.
  • raise_on_not_found: Jeśli wartość to "true", zgłoś błąd, jeśli nie zostanie znaleziony.

• pub async fn get_cache_location(&self) -> Result<String>
  Pobierz lokalizację pamięci podręcznej jako ciąg znaków.

• pub async fn list_cached_models(&mut self) -> Result<Vec<FoundryModelInfo>>
  Wyświetl listę buforowanych modeli.

• pub async fn download_model(&mut self, alias_or_model_id: &str, token: Option<&str>, force: bool) -> Result<FoundryModelInfo>
  Pobierz model.
  argumenty:

  • alias_or_model_id: alias lub identyfikator modelu.
  • token: opcjonalny token uwierzytelniania.
  • force: Wymuś ponowne pobranie, jeśli jest już buforowane.

• pub async fn load_model(&mut self, alias_or_model_id: &str, ttl: Option<i32>) -> Result<FoundryModelInfo>
  Załaduj model do wnioskowania.
  argumenty:

  • alias_or_model_id: alias lub identyfikator modelu.
  • ttl: Opcjonalny czas wygaśnięcia w sekundach.

• pub async fn unload_model(&mut self, alias_or_model_id: &str, force: bool) -> Result<()>
  Rozładować model.
  argumenty:

  • alias_or_model_id: alias lub identyfikator modelu.
  • force: Wymuś odłączenie, nawet jeśli jest używane.

• pub async fn list_loaded_models(&mut self) -> Result<Vec<FoundryModelInfo>>
  Lista załadowanych modeli.

FoundryLocalManagerBuilder

Konstruktor do tworzenia FoundryLocalManager wystąpienia.

Pola formularza

• alias_or_model_id: Option<String> — alias lub identyfikator modelu do pobrania i załadowania.
• bootstrap: bool — czy należy uruchomić usługę, jeśli nie jest uruchomiona.
• timeout_secs: Option<u64> — limit czasu klienta HTTP w sekundach.

Metody

• pub fn new() -> Self
  Utwórz nowe wystąpienie konstruktora.

• pub fn alias_or_model_id(mut self, alias_or_model_id: impl Into<String>) -> Self
  Ustaw alias lub identyfikator modelu, aby pobrać i załadować.

• pub fn bootstrap(mut self, bootstrap: bool) -> Self
  Określ, czy usługa ma być uruchamiana, jeśli nie jest uruchomiona.

• pub fn timeout_secs(mut self, timeout_secs: u64) -> Self
  Ustaw limit czasu klienta HTTP w sekundach.

• pub async fn build(self) -> Result<FoundryLocalManager>
  Skompiluj FoundryLocalManager wystąpienie.

FoundryModelInfo

Reprezentuje informacje o modelu.

Pola formularza

• alias: String — alias dla modelu.
• id: String — identyfikator modelu.
• version: String — wersja modelu.
• runtime: ExecutionProvider — dostawca wykonywania (CPU, CUDA itp.).
• uri: String — identyfikator URI modelu.
• file_size_mb: i32 — Rozmiar pliku modelu w MB.
• prompt_template: serde_json::Value — Szablon monitu dla modelu.
• provider: String — nazwa dostawcy.
• publisher: String — nazwa wydawcy.
• license: String — typ licencji.
• task: String — zadanie modelu (np. generowanie tekstu).

Metody

• from_list_response(response: &FoundryListResponseModel) -> Self
  Tworzy element FoundryModelInfo na podstawie odpowiedzi katalogu.

• to_download_body(&self) -> serde_json::Value
  Konwertuje informacje o modelu na treść JSON na potrzeby żądań pobierania.

ExecutionProvider

Wyliczenie obsługiwanych dostawców wykonawczych.

• CPU
• WebGPU
• CUDA
• QNN

Metody

• get_alias(&self) -> String
  Zwraca alias ciągu dla dostawcy uruchamiania.

ModelRuntime

Opisuje środowisko uruchomieniowe dla modelu.

• device_type: DeviceType
• execution_provider: ExecutionProvider