Gemma 197M: il Modello Task On-Device di Chrome e le Cinque API che Alimenta

La maggior parte della copertura sull'AI integrata di Chrome si concentra sulla Prompt API e su Gemini Nano — il modello general-purpose che consente di scrivere prompt liberi direttamente nel browser. Meno attenzione riceve il secondo modello incluso in Chrome: Gemma 197M, un modello esperto ultra-efficiente annunciato al Google I/O 2026 che alimenta in modo trasparente una suite di API specifiche per compiti. I due modelli servono scopi fondamentalmente diversi, operano su budget di download separati ed espongono interfacce JavaScript del tutto differenti. Capire quando usare l'uno o l'altro è la differenza tra costruire una funzionalità AI flessibile e costruirne una che scala su ogni dispositivo senza costi server (Google Chrome for Developers, 2026).

Questo articolo è un'analisi tecnica approfondita di Gemma 197M: cosa rende la sua architettura abbastanza efficiente da girare in un browser, quali API abilita e come usarle tutte con pattern di livello produttivo. Ogni esempio di codice funziona con le API Chrome stabili a partire da Chrome 148, con controlli di disponibilità e gestione degli errori inclusi.

Due Modelli, Due Ruoli

Lo stack AI on-device di Chrome non è un singolo modello che fa tutto. Separa l'inferenza general-purpose dall'inferenza su compiti specifici, con una buona ragione: un modello ottimizzato per tradurre due frasi non ha bisogno di contenere un modello generale del mondo nei propri pesi. Distribuire uno specialista più piccolo evita il costo in memoria e latenza di instradare ogni compito attraverso l'intero Gemini Nano.

Architettura: Perché 197M Parametri Attivi Sono Sufficienti

L'efficienza di Gemma 197M deriva da due innovazioni architetturali che hanno origine nella famiglia di modelli Gemma 3n. Insieme permettono a Chrome di eseguire un modello con molti meno parametri attivi di quanto il conteggio grezzo dei pesi lascerebbe supporre.

Le Tre Task API Stabili

A partire da Chrome 138, tre API browser specifiche per compiti sono stabili. Funzionano senza flag, token di origin trial o alcuna configurazione lato server.

Summarizer API

Il Summarizer è l'utilizzo di punta di Gemma 197M. Accetta un testo lungo e restituisce un riassunto in uno dei quattro tipi — tldr, key-points, teaser, headline — in testo normale o markdown, a tre impostazioni di lunghezza. L'API espone inputQuota e measureInputUsage() per controllare il budget di token prima dell'invio — fondamentale per i documenti lunghi che potrebbero superare la finestra di contesto.

async function summarize(text, {
  type   = 'key-points',
  format = 'plain-text',
  length = 'medium',
  onProgress,
} = {}) {
  if (!('Summarizer' in self)) throw new Error('Summarizer API not supported');

  const availability = await Summarizer.availability();
  if (availability === 'unavailable') throw new Error('Summarizer not available on this device');

  const summarizer = await Summarizer.create({
    type, format, length,
    outputLanguage: 'en',   // required: 'en' | 'es' | 'ja'
    monitor(m) {
      m.addEventListener('downloadprogress', (e) => {
        const pct = e.total ? Math.round((e.loaded / e.total) * 100) : 0;
        onProgress?.(pct);
      });
    },
  });

  // Check token budget — guard required: not exposed in all builds
  if (typeof summarizer.measureInputUsage === 'function') {
    try {
      const usage = await summarizer.measureInputUsage(text);
      if (usage > summarizer.inputQuota) {
        summarizer.destroy();
        throw new Error(`Input too long: ${usage} tokens, quota is ${summarizer.inputQuota}`);
      }
    } catch (e) {
      if (e.message?.includes('too long')) throw e;
      // TypeError: not implemented in this build — skip quota check
    }
  }

  let result = '';
  const stream = summarizer.summarizeStreaming(text);
  for await (const chunk of stream) {
    // defensive: older builds yield cumulative text; newer builds yield deltas
    if (chunk.startsWith(result)) result = chunk;
    else                          result += chunk;
  }

  summarizer.destroy();
  return result;
}

// Usage
const summary = await summarize(longArticleText, {
  type:   'key-points',
  format: 'markdown',
  length: 'short',
  onProgress: (pct) => console.log(`Model: ${pct}%`),
});

La semantica dei chunk di summarizeStreaming() — e di writeStreaming() e rewriteStreaming() — differisce tra le build di Chrome. Le build più vecchie producono testo cumulativo (ogni chunk contiene tutto il testo prodotto finora); le build più recenti producono delta incrementali. Il pattern difensivo sopra copre entrambi i casi: se il nuovo chunk inizia con il buffer accumulato è cumulativo e lo sostituisce; altrimenti è un delta e viene concatenato. Senza questa guardia, le build cumulative producono output raddoppiato e corrotto quando accumulato con +=.

Language Detector API

Il Language Detector è utile ovunque sia necessario instradare i contenuti generati dagli utenti per lingua — prima della traduzione, prima della selezione del modello, o per presentare l'UI nella lingua rilevata. Restituisce un array di candidati ordinati per confidenza decrescente, coprendo dalla lingua più probabile ai casi limite. Il modello gira interamente on-device; nessun testo viene inviato a un server.

async function detectLanguage(text) {
  if (!('LanguageDetector' in self)) return null;

  const availability = await LanguageDetector.availability();
  if (availability === 'unavailable') return null;

  const detector = await LanguageDetector.create();
  const results = await detector.detect(text);
  detector.destroy();

  // [ { detectedLanguage: 'it', confidence: 0.97 },
  //   { detectedLanguage: 'la', confidence: 0.02 }, ... ]
  return {
    primary:     results[0]?.detectedLanguage ?? 'en',
    confidence:  results[0]?.confidence ?? 0,
    all:         results,
  };
}

// Instrada un ticket di supporto al team giusto per lingua
async function routeTicket(ticketBody) {
  const { primary, confidence } = (await detectLanguage(ticketBody)) ?? {};
  if (confidence > 0.85) {
    return ROUTING_MAP[primary] ?? 'default-queue';
  }
  return 'default-queue'; // fallback bassa confidenza
}

Nota: le API Language Detector e Translator funzionano solo su desktop (Windows, macOS, Linux, ChromeOS). Non sono disponibili nelle versioni Android o iOS di Chrome a partire da Chrome 148 (Google Chrome for Developers, 2026).

Translator API

La Translator API traduce testo tra coppie di lingue on-device. Ogni coppia di lingue richiede il proprio download del modello, quindi è necessario verificare la disponibilità per coppia prima di tentare la traduzione. Il metodo Translator.availability() accetta sourceLanguage e targetLanguage e restituisce lo stato di disponibilità per quella specifica combinazione.

async function translate(text, { from, to }) {
  if (!('Translator' in self)) throw new Error('Translator API not supported');

  // Check pair-specific availability before creating the instance
  const availability = await Translator.availability({
    sourceLanguage: from,
    targetLanguage: to,
  });
  if (availability === 'unavailable') {
    throw new Error(`Translation pair ${from}→${to} not available on this device`);
  }

  const translator = await Translator.create({
    sourceLanguage: from,
    targetLanguage: to,
    monitor(m) {
      m.addEventListener('downloadprogress', (e) => {
        console.log(`Language pair: ${Math.round(e.loaded / e.total * 100)}%`);
      });
    },
  });

  const result = await translator.translate(text);
  translator.destroy();
  return result;
}

// Traduce una recensione utente in inglese per l'elaborazione downstream
const english = await translate('Produit excellent, livraison rapide', {
  from: 'fr',
  to:   'en',
});

Pattern Avanzato: Concatenare le API

Il vero vantaggio di avere tutte e tre le API nello stesso contesto JavaScript è la componibilità. È possibile concatenare Language Detector → Translator → Summarizer per elaborare documenti multilingua interamente lato client — nessun server, nessuna chiave API, nessun dato che lascia il dispositivo. Questo pattern è particolarmente rilevante per le applicazioni enterprise che gestiscono contenuti sensibili o regolamentati.

async function summarizeAnyLanguage(text, {
  summaryType   = 'key-points',
  summaryLength = 'short',
  targetLang    = 'en',
} = {}) {

  // Step 1: Detect source language
  const detection = await detectLanguage(text);
  const sourceLang = detection?.primary ?? targetLang;

  // Step 2: Translate only if needed
  let processText = text;
  if (sourceLang !== targetLang && detection?.confidence > 0.80) {
    try {
      processText = await translate(text, { from: sourceLang, to: targetLang });
    } catch {
      // Pair not available — summarize in original language
    }
  }

  // Step 3: Summarize
  return summarize(processText, { type: summaryType, length: summaryLength });
}

// Elabora un contratto in francese estraendo i punti chiave in inglese
const keyPoints = await summarizeAnyLanguage(frenchContractText, {
  summaryType:   'key-points',
  summaryLength: 'medium',
  targetLang:    'en',
});

Gemma 197M vs Gemini Nano: Scegliere lo Strumento Giusto

Entrambi i modelli sono on-device, entrambi sono privi di costi di token e richiedono entrambi gli stessi ~22 GB di spazio su disco disponibile nel volume del profilo Chrome. Il punto di decisione è la complessità del compito e la flessibilità richiesta.

Checklist di Produzione