Crie experiências híbridas em apps da Apple com modelos hospedados na nuvem e no dispositivo

É possível criar apps e recursos com tecnologia de IA para Apple com inferência híbrida usando Firebase AI Logic. A inferência híbrida permite executar a inferência usando modelos no dispositivo (especificamente o framework Foundation Models da Apple) quando disponível e fazer o fallback para modelos do Google hospedados na nuvem (e vice-versa).

Esta página descreve como começar a usar o SDK do cliente, além de mostrar outras opções e recursos de configuração, como a temperatura.

A inferência no dispositivo via Firebase AI Logic é compatível com apps da Apple que usam o SDK do Firebase AI Logic v12.13.0 ou mais recente e são executados em dispositivos com o Apple Intelligence ativado. Ela é regida pelos requisitos de uso aceitável do framework Foundation Models da Apple.

Casos de uso recomendados

  • O uso de um modelo no dispositivo para inferência oferece:

    • Privacidade aprimorada
    • Inferência sem custo financeiro
    • Funcionalidade off-line

  • O uso da funcionalidade híbrida oferece:

    • Oferecer a todos os clientes uma experiência de app semelhante, independentemente do dispositivo do usuário final
    • Melhorar a disponibilidade de recursos de IA generativa, independentemente da conectividade com a Internet, das limitações de cota ou dos recursos do dispositivo

Recursos, APIs e dispositivos compatíveis

Antes de implementar a inferência híbrida e no dispositivo usando o Firebase AI Logic, revise esta seção para entender o que é compatível com apps da Apple.

Recursos e funcionalidades compatíveis com a inferência no dispositivo

A inferência no dispositivo oferece suporte apenas à geração de texto, especificamente os seguintes recursos de geração de texto:

Confira a lista detalhada de inferências híbridas ou no dispositivo que ainda não são compatíveis na parte de baixo desta página.

APIs e dispositivos compatíveis

Primeiros passos

Confira se você revisou a seção acima que descreve os recursos, APIs e dispositivos compatíveis.

Estas etapas de primeiros passos descrevem a configuração geral necessária para qualquer solicitação de comando compatível que você queira enviar.

Etapa 1: configurar um projeto do Firebase e conectar o app ao Firebase

  1. Faça login no Firebase console, e selecione seu Projeto do Firebase.

  2. No console do Firebase, acesse Serviços de IA > Lógica de IA.

  3. Clique em Primeiros passos para iniciar um fluxo de trabalho guiado que ajuda a configurar as APIs necessárias e os recursos para seu projeto.

  4. Configure seu projeto para usar um provedor "Gemini API".

    Recomendamos começar usando a Gemini Developer API. A qualquer momento, você pode sempre configurar a Vertex AI Gemini API (e o requisito de faturamento).

    Para o Gemini Developer API, o console vai ativar as APIs necessárias e criar uma chave de API Gemini no seu projeto.
    Não adicione essa chave de API Gemini à base de código do seu app.     Saiba mais.

  5. Se solicitado no fluxo de trabalho do console, siga as instruções na tela para registrar seu app e conectá-lo ao Firebase.

  6. Continue para a próxima etapa deste guia para adicionar o SDK ao app.

Etapa 2: adicionar os SDKs necessários

Use o Swift Package Manager (SPM) para instalar e gerenciar dependências do Xcode. O suporte híbrido só está disponível ao usar o SPM.

A biblioteca Firebase AI Logic oferece acesso às APIs para interagir com modelos generativos. A biblioteca está incluída como parte do SDK do Firebase para plataformas Apple (firebase-ios-sdk).

Se você já estiver usando o Firebase, verifique se o pacote do Firebase é a versão 12.13.0 ou mais recente.

  1. No Xcode, com seu projeto do app aberto, navegue até File > Add Package Dependencies.

  2. Quando solicitado, adicione o repositório do SDK do Firebase para as plataformas Apple:

    https://github.com/firebase/firebase-ios-sdk

  3. Selecione a versão mais recente do SDK.

  4. Selecione a biblioteca FirebaseAILogic.

Quando terminar, o Xcode vai começar a resolver e fazer o download das dependências em segundo plano automaticamente.

Etapa 3: inicializar o serviço e criar uma instância de sessão do modelo

Clique no provedor Gemini API para conferir o conteúdo específico do provedor e o código nesta página.

Configure o seguinte antes de enviar uma solicitação de comando ao modelo.

  1. Inicialize o serviço para o provedor Gemini API escolhido.

  2. Crie uma instância GenerativeModelSession com um HybridModel.

  3. Defina os modelos primary e secondary com base nas suas preferências. É possível definir a ordem da inferência tentada:

    • Tentar a inferência no dispositivo primeiro, mas permitir o fallback para a nuvem: defina primary como um modelo de "sistema" e secondary como um modelo de nuvem.

    • Tentar a inferência na nuvem primeiro, mas permitir o fallback para o dispositivo: defina primary como um modelo de nuvem e secondary como um modelo de "sistema".

    O SDK oferece suporte à definição apenas de um único model, o que significa que o SDK vai tentar apenas a inferência no dispositivo ou na nuvem. No entanto, para uma experiência híbrida, é necessário criar um HybridModel e definir os modelos primary e secondary.

    Saiba mais sobre o comportamento dos "modos de inferência" (a ordem da inferência tentada) inferência) em Opções de configuração.

O exemplo a seguir mostra como tentar a inferência no dispositivo primeiro, mas permitir o fallback para o modelo hospedado na nuvem:

// Initialize the Gemini Developer API backend service
let ai = FirebaseAI.firebaseAI(backend: .googleAI())

// Initialize a cloud model that supports your use case
let cloudModel = ai.geminiModel(name: "GEMINI_MODEL_NAME")
// Initialize an on-device model that supports your use case
let systemModel = FirebaseAI.SystemLanguageModel.default

// Create a Hybrid Model
// Provide your preferred model as `primary` and your fallback model as `secondary`
// In this example, attempt to use on-device model; otherwise, fall back to cloud.
let hybridModel = HybridModel(
  primary: systemModel,
  secondary: cloudModel
)

// Create a GenerativeModelSession with the HybridModel created earlier.
let session = firebaseAI.generativeModelSession(
  model: hybridModel,
)

Etapa 4: enviar uma solicitação de comando a um modelo

Esta seção mostra como:

Gerar texto com base em entradas somente de texto

Antes de tentar este exemplo, confira se você concluiu a Primeiros passos seção deste guia.

Para gerar texto com base em um comando que contém texto, use respond(to:) da seguinte maneira:

// Imports + initialization of Gemini API backend service + creation of model session

// Provide a prompt that contains text
let prompt = "Write a story about a magic backpack."

// To generate text output, call `respond(to:)` with the text input
let response = try await session.respond(to: prompt)
print(response.content)

Transmitir texto com base em entradas somente de texto

Antes de tentar este exemplo, confira se você concluiu a Primeiros passos seção deste guia.

É possível conseguir interações mais rápidas sem esperar o resultado completo da geração do modelo e, em vez disso, usar o streaming para processar resultados parciais. Para transmitir texto gerado com base em um comando que contém texto, use streamResponse(to:) da seguinte maneira:

// Imports + initialization of Gemini API backend service + creation of model session

// Provide a prompt that contains text
let prompt = "Write a story about a magic backpack."

// To stream generated text output, call `streamResponse(to:)` with the text input
let stream = session.streamResponse(to: prompt)
for try await snapshot in stream {
  print(snapshot.content)
}

O que mais você sabe fazer?

Você pode usar várias outras opções e recursos de configuração para suas experiências híbridas:

Recursos que ainda não são compatíveis com a inferência híbrida ou no dispositivo

Como um lançamento experimental, nem todos os recursos do Firebase AI Logic ou dos modelos hospedados na nuvem são compatíveis.

  • Os seguintes itens não são compatíveis com implementações híbridas ou no dispositivo: modelos Imagen, a API Gemini Live e modelos de comandos. Além disso, não é possível confiar na contagem de tokens, porque a contagem vai variar entre modelos hospedados na nuvem e no dispositivo. Portanto, não há um fallback intuitivo.

  • Os recursos a seguir ainda não são compatíveis com a inferência no dispositivo. Se você quiser usar algum desses recursos, recomendamos usar apenas um modelo hospedado na nuvem para uma experiência mais consistente.

    • Gerar texto com base em entradas multimodais, como imagens, áudio, vídeo e documentos (PDFs)

    • Gerar mídia, como imagens, áudio ou vídeo

    • Enviar solicitações que excedam 4.096 tokens (ou aproximadamente 3.000 palavras em inglês).

    • Fornecer ao modelo no dispositivo ferramentas integradas para ajudar a gerar a resposta (como execução de código, contexto de URL e Grounding com a Pesquisa Google)

  • O monitoramento de IA no console Firebase não mostra dados para inferência no dispositivo (incluindo registros no dispositivo). No entanto, qualquer inferência que use um modelo hospedado na nuvem pode ser monitorada como outras inferências via Firebase AI Logic.

Outras limitações

Além do acima, a inferência no dispositivo tem as seguintes limitações:


Enviar feedback sobre sua experiência com Firebase AI Logic