Referência do SDK local do Foundry

Referência do SDK do Python

Pré-requisitos

• Instale o Foundry Local e assegure-se de que o comando foundry está disponível no seu PATH sistema.
• Usa Python 3.9 ou posterior.

Instalação

Instale o pacote Python:

pip install foundry-local-sdk

Início Rápido

Use este excerto para verificar se o SDK pode iniciar o serviço e aceder ao catálogo local.

from foundry_local import FoundryLocalManager

manager = FoundryLocalManager()
manager.start_service()

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

Este exemplo imprime um número diferente de zero quando o serviço está em execução e o catálogo está disponível.

Referências:

• Integrar com SDKs de inferência

Classe FoundryLocalManager

A FoundryLocalManager classe fornece métodos para gerenciar modelos, cache e o serviço Foundry Local.

Inicialização

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: (opcional) Alias ou ID do modelo para baixar e carregar na inicialização.
• bootstrap: (padrão True) Se True, inicia o serviço se não estiver em execução e carrega o modelo, se fornecido.

Uma nota sobre pseudónimos

Muitos métodos descritos nesta referência têm um alias_or_model_id parâmetro na assinatura. Você pode passar para o método um alias ou ID de modelo como um valor. O uso de um alias irá:

• Selecione o melhor modelo para o hardware disponível. Por exemplo, se uma GPU Nvidia CUDA estiver disponível, o Foundry Local selecionará o modelo CUDA. Se uma NPU suportada estiver disponível, o Foundry Local selecionará o modelo de NPU.
• Permitir que você use um nome mais curto sem precisar lembrar o ID do modelo.

Gestão de Serviços

Gestão de Catálogos

Gerenciamento de cache

Gestão de Modelos

FoundryModelInfo

Os métodos list_catalog_models(), , e list_cached_models() retornam uma lista de list_loaded_models() objetosFoundryModelInfo. Pode usar a informação contida neste objeto para refinar ainda mais a lista. Ou obter a informação de um modelo diretamente chamando o get_model_info(alias_or_model_id) método.

Estes objetos contêm os seguintes campos:

Fornecedores de Execução

Um dos seguintes:

• CPUExecutionProvider - Execução baseada em CPU
• CUDAExecutionProvider - Execução de GPU NVIDIA CUDA
• WebGpuExecutionProvider - Execução WebGPU
• QNNExecutionProvider - Execução de Rede Neural Qualcomm (NPU)
• OpenVINOExecutionProvider - Execução Intel OpenVINO
• NvTensorRTRTXExecutionProvider - Execução NVIDIA TensorRT
• VitisAIExecutionProvider - Execução de IA AMD Vitis

Exemplo de Utilização

O código a seguir demonstra como usar a FoundryLocalManager classe para gerenciar modelos e interagir com o serviço Foundry Local.

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)

Este exemplo lista modelos, faz o download e carrega um modelo, e depois liberta-o.

Referências:

• Integrar com SDKs de inferência

Integração com OpenAI SDK

Instale o pacote OpenAI:

pip install openai

O código a seguir demonstra como integrar o FoundryLocalManager com o OpenAI SDK para interagir com um modelo local.

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)

Este exemplo transmite uma resposta de conclusão de chat a partir do modelo local.

Referências:

• Integrar com SDKs de inferência

Referência do SDK JavaScript

Pré-requisitos

• Instale o Foundry Local e certifique-se de que foundry o comando está disponível no seu PATH.

Instalação

Instale o pacote a partir do npm:

npm install foundry-local-sdk

Início Rápido

Use este excerto para verificar se o SDK pode iniciar o serviço e aceder ao catálogo local.

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}`);

Este exemplo imprime um número não zero quando o serviço está em execução e o catálogo está disponível.

Referências:

• Integrar com SDKs de inferência

Classe FoundryLocalManager

A FoundryLocalManager classe permite gerenciar modelos, controlar o cache e interagir com o serviço Foundry Local em ambientes de navegador e Node.js.

Inicialização

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

const foundryLocalManager = new FoundryLocalManager();

Opções disponíveis:

• host: URL base do serviço Foundry Local
• fetch: (opcional) Implementação de busca personalizada para ambientes como Node.js

Uma nota sobre pseudónimos

Muitos métodos descritos nesta referência têm um aliasOrModelId parâmetro na assinatura. Você pode passar para o método um alias ou ID de modelo como um valor. O uso de um alias irá:

• Selecione o melhor modelo para o hardware disponível. Por exemplo, se uma GPU Nvidia CUDA estiver disponível, o Foundry Local selecionará o modelo CUDA. Se uma NPU suportada estiver disponível, o Foundry Local selecionará o modelo de NPU.
• Permitir que você use um nome mais curto sem precisar lembrar o ID do modelo.

Gestão de Serviços

Gestão de Catálogos

Gerenciamento de cache

Gestão de Modelos

Exemplo de Utilização

O código a seguir demonstra como usar a FoundryLocalManager classe para gerenciar modelos e interagir com o serviço Foundry Local.

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);

Este exemplo descarrega e carrega um modelo, depois lista os modelos em cache e carregados.

Referências:

• Integrar com SDKs de inferência

Integração com OpenAI Client

Instale o pacote OpenAI:

npm install openai

O código a seguir demonstra como integrar o FoundryLocalManager com o cliente OpenAI para interagir com um modelo local.

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

Este exemplo transmite uma resposta de conclusão de chat a partir do modelo local.

Referências:

• Integrar com SDKs de inferência

Utilização do navegador

O SDK inclui uma versão compatível com browser, onde deve especificar manualmente a URL do anfitrião:

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

Exemplo de Utilização

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);

Referências:

• Integrar com SDKs de inferência

Referência do SDK do C#

Guia de configuração do projeto

Existem dois pacotes NuGet para o Foundry Local SDK – um WinML e um pacote multiplataforma – que têm a mesma superfície de API, mas são otimizados para plataformas diferentes:

• Windows: Utiliza o Microsoft.AI.Foundry.Local.WinML pacote específico para aplicações Windows, que utiliza o framework Windows Machine Learning (WinML).
• Multiplataforma: Utiliza o Microsoft.AI.Foundry.Local pacote que pode ser usado para aplicações multiplataforma (Windows, Linux, macOS).

Dependendo da sua plataforma de destino, siga estas instruções para criar uma nova aplicação C# e adicionar as dependências necessárias:

Use o Foundry Local no seu projeto C# seguindo estas instruções específicas para Windows ou Multiplataforma (macOS/Linux/Windows):

Início Rápido

Use este excerto para verificar se o SDK pode inicializar-se e aceder ao catálogo local de modelos.

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

Este exemplo imprime o número de modelos disponíveis para o seu hardware.

Referências:

• Integrar com SDKs de inferência

Redesign

Para melhorar a sua capacidade de distribuir aplicações usando IA no dispositivo, há alterações substanciais na arquitetura do SDK C# em versões 0.8.0 e versões posteriores. Nesta secção, descrevemos as principais alterações para o ajudar a migrar as suas aplicações para a versão mais recente do SDK.

O diagrama seguinte mostra como a arquitetura anterior – para versões anteriores 0.8.0 – dependia fortemente do uso de um servidor web REST para gerir modelos e inferências, como concluições de chat:

O SDK usaria uma Chamada Procedural Remota (RPC) para encontrar o executável CLI Local da Foundry na máquina, iniciar o servidor web e depois comunicar-se com ele via HTTP. Esta arquitetura tinha várias limitações, incluindo:

• Complexidade na gestão do ciclo de vida do servidor web.
• Implementação desafiante: Os utilizadores finais precisavam de ter a CLI local da Foundry instalada nas suas máquinas e na sua aplicação.
• A gestão de versões do CLI e do SDK pode causar problemas de compatibilidade.

Para resolver estas questões, a arquitetura redesenhada em versão 0.8.0 e posteriormente utiliza uma abordagem mais simplificada. A nova arquitetura é a seguinte:

Nesta nova arquitetura:

• A sua aplicação é independente. Não é necessário instalar a CLI local do Foundry separadamente na máquina do utilizador final, facilitando a implementação de aplicações.
• O servidor web REST é opcional. Ainda podes usar o servidor web se quiseres integrar com outras ferramentas que comunicam via HTTP. Leia Sobre a utilização das conclusões do chat via servidor REST com o Foundry Local para obter detalhes sobre como utilizar esta funcionalidade.
• O SDK tem suporte nativo para completação de conversas e transcrições de áudio, permitindo construir aplicações de IA conversacional com menos dependências. Leia a API de completação nativa de chat do Use Foundry para detalhes sobre como utilizar esta funcionalidade.
• Em dispositivos Windows, pode usar uma versão do Windows ML que gere a aceleração de hardware para modelos no dispositivo, obtendo o runtime e os drivers certos.

Alterações da API

Versão 0.8.0 e versões posteriores fornecem uma API mais orientada a objetos e componível. O principal ponto de entrada continua a ser a FoundryLocalManager classe, mas em vez de ser um conjunto plano de métodos que operam através de chamadas estáticas para uma API HTTP sem estado, o SDK expõe agora métodos na FoundryLocalManager instância que mantêm o estado sobre o serviço e os modelos.

A API permite que o Foundry Local seja mais configurável através do servidor web, registo, localização de cache e seleção de variantes do modelo. Por exemplo, a Configuration classe permite-lhe configurar o nome da aplicação, o nível de registo, URLs do servidor web e diretórios para dados de aplicação, cache de modelos e registos:

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

Referências:

• Integrar com SDKs de inferência

Na versão anterior do Foundry Local C# SDK, não podias configurar estas definições diretamente através do SDK, o que limitava a tua capacidade de personalizar o comportamento do serviço.

Reduzir o tamanho do pacote de aplicação

O SDK Foundry Local puxa o Microsoft.ML.OnnxRuntime.Foundry pacote NuGet como dependência. O Microsoft.ML.OnnxRuntime.Foundry pacote fornece o conjunto de execução de inferência, que é o grupo de bibliotecas necessárias para executar inferência de forma eficiente em dispositivos de hardware específicos de fornecedores. O conjunto de tempo de execução de inferência inclui os seguintes componentes:

• Biblioteca de tempo de execução ONNX: O motor central de inferência (onnxruntime.dll).
• Biblioteca do Provedor de Execução em Tempo de Execução (EP) ONNX. Um backend específico para hardware no ONNX Runtime que otimiza e executa partes de um modelo de aprendizagem automática num acelerador de hardware. Por exemplo:
  • CUDA EP: onnxruntime_providers_cuda.dll
  • QNN EP: onnxruntime_providers_qnn.dll
• Bibliotecas de Fornecedores Independentes de Hardware (IHV). Por exemplo:
  • WebGPU: Dependências DirectX (dxcompiler.dll, dxil.dll)
  • QNN: Dependências da Qualcomm QNN (QnnSystem.dll, etc.)

A tabela seguinte resume quais as bibliotecas EP e IHV que estão incluídas na sua aplicação e o que o WinML irá descarregar/instalar em tempo de execução:

Em todas as plataformas e arquiteturas, é necessário o EP da CPU. As bibliotecas WebGPU EP e IHV são pequenas (por exemplo, a WebGPU só adiciona ~7MB ao pacote da sua aplicação) e são necessárias no Windows e macOS. No entanto, os EPs CUDA e QNN são grandes (por exemplo, o CUDA adiciona ~1GB ao seu pacote de candidatura), por isso recomendamos excluir estes EPs do seu pacote de candidatura. O WinML irá descarregar/instalar CUDA e QNN em tempo de execução se o utilizador final tiver hardware compatível.

Para reduzir o tamanho do seu pacote de aplicação, pode criar um ExcludeExtraLibs.props ficheiro no diretório do seu projeto com o seguinte conteúdo, que exclui as bibliotecas CUDA e QNN EP e IHV quando publica a sua aplicação:

<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>

No seu ficheiro de projeto (.csproj), adicione a seguinte linha para importar o ExcludeExtraLibs.props ficheiro:

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

Windows: dependências CUDA

O CUDA EP é integrado na sua aplicação Linux via Microsoft.ML.OnnxRuntime.Foundry, mas não incluímos as bibliotecas IHV. Se quiser permitir que os seus utilizadores finais com dispositivos compatíveis com CUDA beneficiem de maior desempenho, precisa de adicionar as seguintes bibliotecas IHV CUDA à sua aplicação:

• CUBLAS v12.8.4 (transferido do NVIDIA Developer)
  • cublas64_12.dll
  • cublasLt64_12.dll
• CUDA RT v12.8.90 (download do NVIDIA Developer)
  • cudart64_12.dll
• CUDNN v9.8.0 (descarregar de NVIDIA Developer)
  • cudnn_graph64_9.dll
  • cudnn_ops64_9.dll
  • cudnn64_9.dll
• CUDA FFT v11.3.3.83 (fazer download de NVIDIA Developer)
  • cufft64_11.dll

Samples

• Para aplicações de exemplo que demonstram como usar o Foundry Local C# SDK, consulte o repositório Foundry Local C# Samples GitHub.

Referência da API

• Para mais detalhes sobre o Foundry Local C# SDK, leia a Foundry Local C# SDK API Reference.

Referência do SDK do Rust

O SDK do Rust para Foundry Local fornece uma maneira de gerenciar modelos, controlar o cache e interagir com o serviço Foundry Local.

Pré-requisitos

• Instale o Foundry Local e certifique-se de que o comando foundry está disponível no seu PATH sistema.
• Usa o Rust 1.70.0 ou posterior.

Instalação

Para usar o SDK do Foundry Local Rust, adicione o seguinte ao seu Cargo.toml:

[dependencies]
foundry-local = "0.1.0"

Como alternativa, pode adicionar a caixa Foundry Local usando cargo:

cargo add foundry-local

Início Rápido

Use este excerto para verificar se o SDK pode iniciar o serviço e ler o catálogo local.

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

Este exemplo imprime um número não zero quando o serviço está em execução e o catálogo está disponível.

Referências:

• Fundição Documentação local
• Documentação do Pacote Foundry-Local

FoundryLocalManager

Gerente de operações do SDK local do Foundry.

Campos

• service_uri: Option<String> — URI do serviço de fundição.
• client: Option<HttpClient> — Cliente HTTP para solicitações de API.
• catalog_list: Option<Vec<FoundryModelInfo>> — Lista em cache de modelos de catálogo.
• catalog_dict: Option<HashMap<String, FoundryModelInfo>> — Dicionário em cache de modelos de catálogo.
• timeout: Option<u64> — Tempo limite opcional do cliente HTTP.

Metodologia

• pub fn builder() -> FoundryLocalManagerBuilder
  Crie um novo construtor para FoundryLocalManager.

• pub fn service_uri(&self) -> Result<&str>
  Obtenha o URI de serviço.
  Retorno: URI do serviço Foundry.

• fn client(&self) -> Result<&HttpClient>
  Obtenha a instância do cliente HTTP.
  Devoluções: Cliente HTTP.

• pub fn endpoint(&self) -> Result<String>
  Obtenha o ponto final para o serviço.
  Devoluções: URL do ponto final.

• pub fn api_key(&self) -> String
  Obtenha a chave de API para autenticação.
  Devoluções: Chave da API.

• pub fn is_service_running(&mut self) -> bool
  Verifique se o serviço está em execução e defina o URI do serviço, se encontrado.
  Devoluções:true se estiver em execução, false caso contrário.

• pub fn start_service(&mut self) -> Result<()>
  Inicie o serviço Foundry Local.

• pub async fn list_catalog_models(&mut self) -> Result<&Vec<FoundryModelInfo>>
  Obtenha uma lista de modelos disponíveis no catálogo.

• pub fn refresh_catalog(&mut self)
  Atualize o cache do catálogo.

• pub async fn get_model_info(&mut self, alias_or_model_id: &str, raise_on_not_found: bool) -> Result<FoundryModelInfo>
  Obtenha informações do modelo por alias ou ID.
  Argumentos:

  • alias_or_model_id: Alias ou ID do modelo.
  • raise_on_not_found: Se verdadeiro, erro se não encontrado.

• pub async fn get_cache_location(&self) -> Result<String>
  Obtenha o local do cache como uma cadeia de caracteres.

• pub async fn list_cached_models(&mut self) -> Result<Vec<FoundryModelInfo>>
  Listar modelos armazenados em cache.

• pub async fn download_model(&mut self, alias_or_model_id: &str, token: Option<&str>, force: bool) -> Result<FoundryModelInfo>
  Faça o download de um modelo.
  Argumentos:

  • alias_or_model_id: Alias ou ID do modelo.
  • token: Token de autenticação opcional.
  • force: Forçar novo download se já estiver armazenado em cache.

• pub async fn load_model(&mut self, alias_or_model_id: &str, ttl: Option<i32>) -> Result<FoundryModelInfo>
  Carregue um modelo para inferência.
  Argumentos:

  • alias_or_model_id: Alias ou ID do modelo.
  • ttl: Tempo de vida opcional em segundos.

• pub async fn unload_model(&mut self, alias_or_model_id: &str, force: bool) -> Result<()>
  Descarregue um modelo.
  Argumentos:

  • alias_or_model_id: Alias ou ID do modelo.
  • force: Forçar a descarga mesmo se estiver em uso.

• pub async fn list_loaded_models(&mut self) -> Result<Vec<FoundryModelInfo>>
  Listar modelos carregados.

FoundryLocalManagerBuilder

Construtor para criar uma FoundryLocalManager instância.

Campos

• alias_or_model_id: Option<String> — Alias ou ID do modelo para baixar e carregar.
• bootstrap: bool — Se o serviço deve ser iniciado se não estiver em execução.
• timeout_secs: Option<u64> — Tempo limite do cliente HTTP em segundos.

Metodologia

• pub fn new() -> Self
  Crie uma nova instância do construtor.

• pub fn alias_or_model_id(mut self, alias_or_model_id: impl Into<String>) -> Self
  Defina o alias ou ID do modelo para baixar e carregar.

• pub fn bootstrap(mut self, bootstrap: bool) -> Self
  Defina se o serviço deve ser iniciado se não estiver em execução.

• pub fn timeout_secs(mut self, timeout_secs: u64) -> Self
  Defina o tempo limite do cliente HTTP em segundos.

• pub async fn build(self) -> Result<FoundryLocalManager>
  Crie a FoundryLocalManager instância.

FoundryModelInfo

Representa informações sobre um modelo.

Campos

• alias: String — O alias do modelo.
• id: String — O ID do modelo.
• version: String — A versão do modelo.
• runtime: ExecutionProvider — O provedor de execução (CPU, CUDA, etc.).
• uri: String — O modelo URI.
• file_size_mb: i32 — Tamanho do ficheiro do modelo em MB.
• prompt_template: serde_json::Value — Modelo de prompt para o modelo.
• provider: String — Nome do fornecedor.
• publisher: String — Nome do editor.
• license: String — Tipo de licença.
• task: String — Tarefa de modelo (por exemplo, geração de texto).

Metodologia

• from_list_response(response: &FoundryListResponseModel) -> Self
  Cria um FoundryModelInfo a partir de uma resposta do catálogo.

• to_download_body(&self) -> serde_json::Value
  Converte as informações do modelo em um corpo JSON para solicitações de download.

ExecutionProvider

Enum para provedores de execução suportados.

• CPU
• WebGPU
• CUDA
• QNN

Metodologia

• get_alias(&self) -> String
  Retorna um alias de cadeia de caracteres para o provedor de execução.

ModelRuntime

Descreve o ambiente de tempo de execução para um modelo.

• device_type: DeviceType
• execution_provider: ExecutionProvider