Referência do SDK Local do Foundry

Referência do SDK do Python

Pré-requisitos

• Instale o Foundry Local e verifique se o foundry comando está disponível em seu PATH.
• Use o Python 3.9 ou posterior.

Instalação

Instale o pacote do Python:

pip install foundry-local-sdk

Início Rápido

Use este snippet para verificar se o SDK pode iniciar o serviço e acessar o 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 Local do Foundry.

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, iniciará o serviço se não estiver em execução e carregará o modelo, se fornecido.

Uma anotação sobre aliases

Muitos métodos descritos nessa referência têm um alias_or_model_id parâmetro na assinatura. Você pode passar para o método um alias ou uma ID de modelo como um valor. Usar um alias levará a:

• 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 com suporte estiver disponível, o Foundry Local selecionará o modelo de NPU.
• Permita que você use um nome mais curto sem precisar se lembrar da ID do modelo.

Gerenciamento de Serviços

Gerenciamento de Catálogo

Gerenciamento de cache

Gerenciamento de Modelos

FoundryModelInfo

Os métodos list_catalog_models()e list_cached_models()list_loaded_models() retornam uma lista de FoundryModelInfo objetos. Você pode usar as informações contidas neste objeto para refinar ainda mais a lista. Ou obtenha as informações de um modelo diretamente chamando o get_model_info(alias_or_model_id) método.

Esses objetos contêm os seguintes campos:

Provedores de execução

Um destes:

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

Exemplo de Uso

O código a seguir demonstra como usar a FoundryLocalManager classe para gerenciar modelos e interagir com o serviço Local do 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)

Este exemplo lista modelos, baixa e carrega um modelo e, em seguida, descarrega-o.

Referências:

• Integrar com SDKs de inferência

Integrar com o SDK do OpenAI

Instale o pacote OpenAI:

pip install openai

O código a seguir demonstra como integrar o FoundryLocalManager SDK do OpenAI 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 do chat do modelo local.

Referências:

• Integrar com SDKs de inferência

Referência do SDK do JavaScript

Pré-requisitos

• Instale o Foundry Local e verifique se o foundry comando está disponível em seu PATH.

Instalação

Instale o pacote do npm:

npm install foundry-local-sdk

Início Rápido

Use este snippet para verificar se o SDK pode iniciar o serviço e acessar o 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 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 permite que você gerencie modelos, controle o cache e interaja com o serviço Local do Foundry 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 anotação sobre aliases

Muitos métodos descritos nessa referência têm um aliasOrModelId parâmetro na assinatura. Você pode passar para o método um alias ou uma ID de modelo como um valor. Usar um alias levará a:

• 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 com suporte estiver disponível, o Foundry Local selecionará o modelo de NPU.
• Permita que você use um nome mais curto sem precisar se lembrar da ID do modelo.

Gerenciamento de Serviços

Gerenciamento de Catálogo

Gerenciamento de cache

Gerenciamento de Modelos

Exemplo de Uso

O código a seguir demonstra como usar a FoundryLocalManager classe para gerenciar modelos e interagir com o serviço Local do 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);

Este exemplo baixa e carrega um modelo e, em seguida, lista modelos armazenados em cache e carregados.

Referências:

• Integrar com SDKs de inferência

Integração com o Cliente OpenAI

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 em fluxo contínuo uma resposta de conclusão de um chat do modelo local.

Referências:

• Integrar com SDKs de inferência

Uso do Navegador

O SDK inclui uma versão compatível com o navegador em que você deve especificar a URL do host manualmente:

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 Uso

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

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

• Windows: Usa o Microsoft.AI.Foundry.Local.WinML pacote específico para aplicativos do Windows, que usa a estrutura do WinML (Windows Machine Learning).
• Multiplataforma: usa o Microsoft.AI.Foundry.Local pacote que pode ser usado para aplicativos multiplataforma (Windows, Linux, macOS).

Dependendo da plataforma de destino, siga estas instruções para criar um novo aplicativo C# e adicionar as dependências necessárias:

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

Início Rápido

Use este snippet para verificar se o SDK pode inicializar e acessar o catálogo de modelos 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()}");

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

Referências:

• Integrar com SDKs de inferência

Reprojetar

Para melhorar sua capacidade de enviar aplicativos usando a IA no dispositivo, há alterações substanciais na arquitetura do SDK do C# na versão 0.8.0 e posterior. Nesta seção, descrevemos as principais alterações para ajudá-lo a migrar seus aplicativos para a versão mais recente do SDK.

O diagrama a seguir mostra como a arquitetura anterior - para versões anteriores ao 0.8.0 - dependia fortemente do uso de um servidor web REST para gerenciar modelos e inferências, como finalizações de chat.

O SDK usaria uma RPC (Chamada de Procedimento Remoto) para localizar o executável da CLI Local do Foundry no computador, iniciaria o servidor Web e se comunicaria com ele por HTTP. Essa arquitetura tinha várias limitações, incluindo:

• Complexidade no gerenciamento do ciclo de vida do webserver.
• Implantação desafiadora: os usuários finais precisavam ter a CLI Local do Foundry instalada em seus computadores e em seu aplicativo.
• O gerenciamento de versão da CLI e do SDK pode levar a problemas de compatibilidade.

Para resolver esses problemas, a arquitetura reprojetada na versão 0.8.0 e posterior usa uma abordagem mais simplificada. A nova arquitetura é a seguinte:

Nesta nova arquitetura:

• Seu aplicativo é autossuficiente. Ele não exige que a CLI Local do Foundry seja instalada separadamente no computador do usuário final, facilitando a implantação de aplicativos.
• O servidor Web REST é opcional. Você ainda poderá usar o servidor Web se quiser se integrar a outras ferramentas que se comunicam por HTTP. Leia Usar conclusões de chat por meio do servidor REST com Fábrica local para obter detalhes sobre como usar esse recurso.
• O SDK tem suporte nativo para conclusões de chat e transcrições de áudio, permitindo que você crie aplicativos de IA de conversa com menos dependências. Leia Usar a API de conclusões de chat nativo da Fábrica local para obter detalhes sobre como usar esse recurso.
• Em dispositivos Windows, você pode usar uma versão do Windows ML que lida com a aceleração de hardware para modelos no dispositivo através da importação do runtime e dos drivers corretos.

Alterações de API

A versão 0.8.0 e posteriores fornecem uma API mais orientada a objetos e composível. O ponto de entrada principal continua sendo a classe FoundryLocalManager, mas, em vez de ser um conjunto simples de métodos que operam por meio de chamadas estáticas para uma API HTTP sem estado, o SDK agora expõe métodos na instância FoundryLocalManager que mantém estado a respeito do serviço e dos modelos.

A API permite que a Fábrica local seja mais configurável no servidor Web, log, local do cache e seleção de variante do modelo. Por exemplo, a Configuration classe permite que você configure o nome do aplicativo, o nível de log, as URLs do servidor Web e os diretórios para dados do aplicativo, cache de modelo e logs:

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 SDK do C# Local do Foundry, você não pôde definir essas configurações diretamente por meio do SDK, o que limitou sua capacidade de personalizar o comportamento do serviço.

Reduzir o tamanho do pacote do aplicativo

O SDK do Foundry Local puxa o Microsoft.ML.OnnxRuntime.Foundry pacote NuGet como uma dependência. O Microsoft.ML.OnnxRuntime.Foundry pacote fornece o pacote de runtime de inferência, que é o conjunto de bibliotecas necessárias para executar com eficiência a inferência em dispositivos de hardware de fornecedor específicos. O pacote de runtime de inferência inclui os seguintes componentes:

• Biblioteca de runtime do ONNX: o mecanismo de inferência principal (onnxruntime.dll).
• Biblioteca do EP (Provedor de Execução de Runtime) do ONNX. Um back-end específico para hardware no ONNX Runtime que otimiza e executa partes de um modelo de aprendizado de máquina em um acelerador de hardware. Por exemplo:
  • CUDA EP: onnxruntime_providers_cuda.dll
  • QNN EP: onnxruntime_providers_qnn.dll
• Bibliotecas de IHV (Fornecedor de Hardware Independente). Por exemplo:
  • WebGPU: dependências do DirectX (dxcompiler.dll, dxil.dll)
  • QNN: dependências do QNN da Qualcomm (QnnSystem.dll, etc.)

A tabela a seguir resume quais bibliotecas EP e IHV são agrupadas com seu aplicativo e o que o WinML baixará/instalará em runtime:

Em todas as plataformas e arquiteturas, o EP da CPU é necessário. As bibliotecas DE EP e IHV da WebGPU são pequenas de tamanho (por exemplo, WebGPU adiciona apenas ~7 MB ao pacote de aplicativos) e são necessárias no Windows e no macOS. No entanto, os EPs CUDA e QNN são grandes em tamanho (por exemplo, CUDA adiciona ~1 GB ao pacote de aplicativos), portanto, recomendamos excluir esses EPs do pacote de aplicativos. O WinML baixará/instalará CUDA e QNN em runtime se o usuário final tiver hardware compatível.

Para reduzir o tamanho do pacote de aplicativos, você pode criar um ExcludeExtraLibs.props arquivo no diretório do projeto com o seguinte conteúdo, que exclui as bibliotecas CUDA e QNN EP e IHV ao publicar seu aplicativo:

<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 arquivo de projeto (.csproj), adicione a seguinte linha para importar o ExcludeExtraLibs.props arquivo:

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

Windows: as dependências do CUDA

O EP CUDA é integrado ao seu aplicativo Linux por meio de Microsoft.ML.OnnxRuntime.Foundry, mas não incluímos as bibliotecas IHV. Se você quiser permitir que os usuários finais com dispositivos habilitados para CUDA se beneficiem de um desempenho mais alto, você precisará adicionar as seguintes bibliotecas de IHV cuda ao seu aplicativo:

• CUBLAS v12.8.4 (download de NVIDIA Developer)
  • cublas64_12.dll
  • cublasLt64_12.dll
• CUDA RT v12.8.90 (faça o download de NVIDIA Developer)
  • cudart64_12.dll
• CUDNN v9.8.0 (baixar do NVIDIA Developer)
  • cudnn_graph64_9.dll
  • cudnn_ops64_9.dll
  • cudnn64_9.dll
• CUDA FFT v11.3.3.83 (faça o download no NVIDIA Developer)
  • cufft64_11.dll

Samples

• Para obter aplicativos de exemplo que demonstram como usar o SDK do C# Local do Foundry, consulte o repositório GitHub de Exemplos de SDK do C# Local do Foundry.

Referência de API

• Para obter mais detalhes sobre o SDK do C# Local do Foundry, leia a Referência da API do SDK do C# Local do Foundry.

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 Local do Foundry.

Pré-requisitos

• Instale o Foundry Local e verifique se o foundry comando está disponível em seu PATH.
• Use o Rust 1.70.0 ou posterior.

Instalação

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

[dependencies]
foundry-local = "0.1.0"

Como alternativa, você pode adicionar o crate Foundry Local usando cargo:

cargo add foundry-local

Início Rápido

Use este snippet 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 diferente de zero quando o serviço está em execução e o catálogo está disponível.

Referências:

• Documentação do Foundry Local
• documentação de crate específica da foundry

FoundryLocalManager

Gerenciador de operações do SDK Local do Foundry.

Campos

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

Métodos

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

• pub fn service_uri(&self) -> Result<&str>
  Obtenha o URI do serviço.
  Retorna: URI do serviço Fábrica.

• fn client(&self) -> Result<&HttpClient>
  Obtenha a instância do cliente HTTP.
  Retorna: cliente HTTP.

• pub fn endpoint(&self) -> Result<String>
  Obtenha o ponto de extremidade do serviço.
  Retorna: URL do ponto de extremidade.

• pub fn api_key(&self) -> String
  Obtenha a chave de API para autenticação.
  Retorna: chave de 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.
  Retorna:true se estiver em execução, caso contrário, false.

• 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 de modelo por alias ou ID.
  Argumentos:

  • alias_or_model_id: Alias ou ID do modelo.
  • raise_on_not_found: se for true. Erro, se não for 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>
  Baixe um modelo.
  Argumentos:

  • alias_or_model_id: Alias ou ID do modelo.
  • token: token de autenticação opcional.
  • force: force o download novamente 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 útil 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: force o descarregamento mesmo se ele estiver em uso.

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

FoundryLocalManagerBuilder

Construtor para criar uma instância de FoundryLocalManager.

Campos

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

Métodos

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

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

• pub fn bootstrap(mut self, bootstrap: bool) -> Self
  Defina se o serviço 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>
  Compile a instância de FoundryLocalManager.

FoundryModelInfo

Representa informações sobre um modelo.

Campos

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

Métodos

• from_list_response(response: &FoundryListResponseModel) -> Self
  Cria uma resposta FoundryModelInfo com base em um 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

Enumeração para provedores de execução com suporte.

• CPU
• WebGPU
• CUDA
• QNN

Métodos

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

ModelRuntime

Descreve o ambiente de runtime de um modelo.

• device_type: DeviceType
• execution_provider: ExecutionProvider