Gemma + LiteRT-LM: Rodando IA Localmente no Flutter sem Conexão

IA Rodando Direto no Dispositivo

Uma das maiores tendências em IA para dispositivos móveis é a capacidade de rodar modelos de linguagem localmente, sem depender de servidores na nuvem. O Gemma (modelo de IA do Google) combinado com o LiteRT-LM (SDK de inferência) torna isso possível no Flutter.

Isso significa: IA que funciona offline, com privacidade total e sem custos de API.

O que é o Gemma?

O Gemma é uma família de modelos de linguagem de código aberto criada pelo Google. Diferente do Gemini (que roda na nuvem), o Gemma foi projetado para rodar em dispositivos locais.

Versões Disponíveis

Gemma 2B — 2 bilhões de parâmetros, ideal para dispositivos modestos
Gemma 7B — 7 bilhões de parâmetros, melhor qualidade
Gemma 4 E2B — Versão otimizada para edge, 2 bilhões de parâmetros
Gemma 4 E4B — Versão otimizada para edge, 4 bilhões de parâmetros

O Gemma 4 (lançado recentemente) é especialmente otimizado para rodar em dispositivos móveis com performance excelente.

O que é o LiteRT-LM?

O LiteRT-LM (anteriormente TensorFlow Lite) é o SDK do Google para inferência de modelos de IA em dispositivos. Ele permite que modelos treinados sejam executados de forma otimizada em:

Android
iOS
macOS
Windows
Linux
Web (via WASM)
Dispositivos IoT

Como Funciona no Flutter

A integração entre Gemma e Flutter é feita através do flutter_gemma ou APIs diretas do LiteRT-LM:

1. Instalação

dependencies:
  flutter_gemma: ^latest
  # ou
  litert_lm: ^latest

2. Baixar o Modelo

O modelo precisa ser baixado e armazenado localmente. Recomende um processo de onboarding na primeira execução:

class ModelDownloader extends StatefulWidget {
  @override
  _ModelDownloaderState createState() => _ModelDownloaderState();
}

class _ModelDownloaderState extends State {
  double progress = 0;
  
  Future downloadModel() async {
    // Verificar espaço disponível
    final dir = await getApplicationDocumentsDirectory();
    final freeSpace = await DiskSpace.getFreeDiskSpace();
    
    if (freeSpace < 2000) { // 2GB mínimo
      mostrarErro('Espaço insuficiente');
      return;
    }
    
    // Baixar modelo
    final file = File('${dir.path}/gemma-4-e2b.bin');
    await downloadWithProgress(
      url: 'https://huggingface.co/litert-community/gemma-4-E2B-it-litert-lm',
      file: file,
      onProgress: (p) => setState(() => progress = p),
    );
  }
  
  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        if (progress < 1)
          CircularProgressIndicator(value: progress),
        if (progress >= 1)
          Text('Modelo pronto!'),
      ],
    );
  }
}

3. Rodar Inferência

import 'package:flutter_gemma/flutter_gemma.dart';

// Inicializar o modelo
final model = await GemmaModel.load(
  modelPath: '${dir.path}/gemma-4-e2b.bin',
  nThreads: 4, // Número de threads
);

// Gerar texto
final response = await model.generate(
  prompt: 'Explique o que é Flutter',
  maxTokens: 500,
  temperature: 0.7,
);

print(response);

// Chat com histórico
final chat = await model.startChat();
await chat.addMessage('Olá!');
final resposta = await chat.generate();
print(resposta);

4. Interface de Chat

class LocalAIChat extends StatefulWidget {
  @override
  _LocalAIChatState createState() => _LocalAIChatState();
}

class _LocalAIChatState extends State<LocalAIChat> {
  final TextEditingController _controller = TextEditingController();
  List<Message> messages = [];
  late ChatSession chat;

  @override
  void initState() {
    super.initState();
    initChat();
  }

  Future<void> initChat() async {
    final model = await GemmaModel.load(modelPath: 'path/to/model.bin');
    chat = await model.startChat();
  }

  Future<void> sendMessage() async {
    final text = _controller.text;
    setState(() {
      messages.add(Message(text: text, isUser: true));
    });

    final response = await chat.generate(prompt: text);

    setState(() {
      messages.add(Message(text: response, isUser: false));
    });
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        Expanded(
          child: ListView.builder(
            itemCount: messages.length,
            itemBuilder: (context, index) {
              final msg = messages[index];
              return ListTile(
                title: Text(msg.text),
                trailing: Icon(msg.isUser ? Icons.person : Icons.android),
              );
            },
          ),
        ),
        TextField(
          controller: _controller,
          onSubmitted: (_) => sendMessage(),
        ),
      ],
    );
  }
}

Vantagens da IA Local

1. Privacidade

Os dados nunca saem do dispositivo. Ideal para apps de saúde, financeiros ou qualquer contexto sensível.

2. Funciona Offline

Sem necessidade de conexão com a internet. Perfeito para viagens, áreas remotas ou modo avião.

3. Sem Custo de API

Uma vez baixado, não há custos por chamada. Economia significativa em apps com alto volume.

4. Latência Mínima

Respostas instantâneas sem esperar round-trips de rede.

Limitações e Cuidados

Espaço em disco — Modelos ocupam de 1GB a 4GB
Memória RAM — Dispositivos precisam de RAM suficiente (mínimo 4GB recomendado)
Bateria — Inferência local consome mais bateria
Qualidade — Modelos menores são menos precisos que Gemini ou GPT
Download inicial — Precisa baixar o modelo antes do primeiro uso

Casos de Uso Ideais

Chat offline — Assistente pessoal sem internet
Tradução — Traduzir texto sem conexão
Resumo de documentos — Processar documentos sensíveis localmente
Autocompletar — Sugestões de texto em apps de escrita
Classificação — Categorizar dados sem enviar para a nuvem

Comparação: Local vs Nuem

Latência — Local: ~50ms | Nuvem: ~500ms+
Custo — Local: 0 (após download) | Nuvem: $ por chamada
Privacidade — Local: 100% | Nuvem: Depende do provedor
Qualidade — Local: Boa (modelos menores) | Nuvem: Excelente (modelos maiores)
Offline — Local: Sim | Nuvem: Não

Conclusão

A combinação de Gemma + LiteRT-LM abre possibilidades incríveis para apps Flutter. Rodar IA localmente significa privacidade, performance e economia. À medida que modelos locais melhoram, cada vez mais aplicações poderão beneficiar dessa abordagem.

Já pensou em adicionar IA offline ao seu app? Qual seria o caso de uso? Conta nos comentários!