# General Translation Knowledge Base: Come fornire alla traduzione AI un contesto sufficiente per le stringhe software?
URL: https://generaltranslation.com/it/kb/ai-translation-context.mdx
Docs index: https://generaltranslation.com/llms.txt
Description: Traduci messaggi completi corredati di note sul significato, ruolo dei segnaposto, limiti di lunghezza e terminologia condivisa. La CLI di General Translation estrae il JSX contrassegnato come blocco strutturato e trasmette le note di contesto alla generazione. Per i cataloghi JSON e YAML esistenti, i metadati associati alle chiavi forniscono istruzioni specifiche per ogni stringa. I gruppi di contesto applicano il tuo Glossario e i tuoi Prompt Personalizzati a tutti i progetti assegnati, e i revisori correggono il risultato nella dashboard.
Category: Traduzione
Last updated: 2026-11-13
Authors: Jackie Chen
Published: 2026-11-13

Una breve stringa dell&#39;interfaccia può avere più traduzioni corrette. Prendiamo &quot;Free&quot;: su un badge dei prezzi significa &quot;gratuito&quot; (in tedesco *kostenlos*), mentre sulla mappa dei posti significa &quot;disponibile&quot; (in tedesco *frei*). La parola da sola non basta a capire quale significato intendi. Fornisci le informazioni che chiederebbe un traduttore umano: che cosa descrive il testo e che cosa può fare l&#39;utente a quel punto.

## Di quale contesto ha bisogno un modello di traduzione?

| Contesto                               | Cosa comunica al modello                                                                     | Esempio                                                                                      | Come fornirlo                                     |
| -------------------------------------- | -------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- | ------------------------------------------------- |
| La frase o il blocco di UI circostante | Come si legano le parole tra loro, inclusi link e formattazione                              | &quot;Leggi i nostri **termini** prima di continuare&quot;, tradotta come un&#39;unica frase | Tradurre blocchi interi, non frammenti            |
| Una nota sul significato               | Quale accezione di una parola ambigua si intende                                             | &quot;Free&quot; nel senso di &quot;disponibile&quot;                                        | Una descrizione, un commento o una nota `context` |
| Ruolo nella UI e limite di lunghezza   | Se si tratta di un pulsante, di un titolo o di un tooltip, e quanto spazio ha a disposizione | Un&#39;etichetta di scheda che non deve superare i 12 caratteri                              | Una nota sul ruolo e una lunghezza massima        |
| Variabili e segnaposto                 | Cosa contiene un valore e il fatto che non va tradotto                                       | `{name}` è il nome di battesimo di una persona                                               | Sintassi dei segnaposto e una nota                |
| Terminologia                           | Nomi di prodotto e termini con un&#39;unica traduzione approvata                             | &quot;Workspace&quot; non va mai tradotto con &quot;ufficio&quot;                            | Un glossario                                      |
| Tono e formalità                       | Il modo in cui il prodotto si rivolge all&#39;utente                                         | Il *Sie* formale in tedesco                                                                  | Regole di stile                                   |
| Dove compare                           | Com&#39;è fatta la schermata attorno alla stringa                                            | Uno screenshot della pagina di checkout                                                      | Screenshot allegati in un TMS                     |

Terminologia e regole di stile valgono per tutte le stringhe, quindi basta impostarle una volta sola. La [guida al glossario](/kb/ai-translation-glossary) spiega come mantenere coerente la terminologia. Il resto è contesto specifico di ogni singola stringa, ed è proprio qui che i flussi di lavoro si differenziano di più.

## In che modo i flussi di lavoro basati su cataloghi forniscono il contesto?

Quando le stringhe si trovano in cataloghi chiave-valore, il contesto viaggia in campi associati a ciascuna chiave:

* **Descrizioni dei messaggi.** I [descrittori di messaggio di react-intl](https://formatjs.github.io/docs/react-intl/api#message-descriptor) accettano una `description` che l&#39;estrazione può conservare. I file PO di gettext prevedono commenti estratti (`#.`) per i traduttori e [`msgctxt`](https://www.gnu.org/software/gettext/manual/html_node/Contexts.html) per distinguere stringhe identiche con significati diversi.
* **Commenti della piattaforma.** I file XML di Android e i file `.strings` di Apple supportano i commenti; gli String Catalog di Apple e le voci `.resx` di .NET hanno campi dedicati ai commenti. L&#39;esportazione e l&#39;integrazione di traduzione devono conservare queste note lungo tutto il processo.
* **Nomi delle chiavi.** Una chiave come `pricing.badge.free` suggerisce il significato, ma un modello non può farvi affidamento. La [guida alla denominazione delle chiavi](/kb/i18n-key-naming) spiega come assegnare alle chiavi nomi basati sul significato.
* **Campi del TMS.** I sistemi di gestione delle traduzioni aggiungono a ogni chiave descrizioni, screenshot e limiti di caratteri. [SimpleLocalize](/kb/general-translation-vs-simplelocalize), ad esempio, conserva per ogni chiave una descrizione del codice scritta dallo sviluppatore e una descrizione per il traduttore. [SimpleLocalize AI](https://simplelocalize.io/docs/general/auto-translation/#simplelocalize-ai) usa queste descrizioni, screenshot e commenti durante la traduzione.

Mantieni ogni frase intera, con i relativi segnaposto e markup. Un catalogo lo consente raccogliendola sotto un&#39;unica chiave; spezzarla in frammenti tradotti separatamente rende più difficile riordinarne le parti. Verifica poi che le note arrivino effettivamente alla fase di traduzione. Una descrizione in un editor o in un file sorgente serve solo se l&#39;integrazione la trasmette.

## In che modo General Translation invia il contesto dal tuo codice?

General Translation parte dal componente. [`<T>`](/docs/react/reference/components/t) contrassegna un blocco di JSX e la CLI ne estrae il testo, la struttura degli elementi, i segnaposto per variabili e la nota da inviare al servizio di traduzione. L&#39;SDK renderizza poi il risultato con i valori di runtime della tua applicazione:

```tsx title="src/SeatStatus.tsx"
import { T, Var } from 'gt-react';

export function SeatStatus({ seat }: { seat: string }) {
  return (
    <T context="Seat map. Free means the seat is available, not that it costs nothing.">
      <p>
        Seat <Var>{seat}</Var> is free. <a href="/checkout">Book it now</a>
      </p>
    </T>
  );
}
```

* **L&#39;unità è il blocco.** La frase, il segnaposto del posto e il testo del link vengono inviati insieme, così il servizio può tradurli e riordinarli preservando gli elementi. Il valore di runtime del posto resta nell&#39;app. La [guida al JSX condizionale](/kb/translate-conditional-jsx) mostra come funziona per le frasi con rami.
* **Note e limiti accanto al testo.** La prop `context` risolve le ambiguità e la prop `maxChars` richiede un limite di lunghezza best-effort, ad esempio `<T maxChars={12}>` sull&#39;etichetta di una scheda. Le stringhe al di fuori del JSX accettano le stesse opzioni in [`gt()`](/docs/react/reference/hooks/use-gt), come `$context` e `$maxChars`.
* **Il codice sorgente come contesto.** In `files.gt.parsingFlags` all&#39;interno di `gt.config.json`, imposta `includeSourceCodeContext` su `true` per inviare le righe di codice circostanti come contesto aggiuntivo. L&#39;opzione è opt-in e integra il blocco estratto. (Vedi [parsing del contenuto inline](/docs/cli/reference/formats/gt-jsx-files#parsing).)
* **Valori da non tradurre.** Racchiudi nomi, email e altri valori dinamici in [`<Var>`](/docs/react/reference/components/var): il loro contenuto non viene inviato per la traduzione e la traduzione mantiene il segnaposto nella sua posizione.
* **Contesto per i cataloghi esistenti.** Per i file JSON e YAML, un file associato di [metadati associati alle chiavi](/docs/cli/reference/keyed-metadata) aggiunge una nota `context` e un limite `maxChars` per ogni chiave. I commenti nei file [Android `strings.xml`](/docs/cli/reference/formats/android-strings-files), [Apple `.strings`](/docs/cli/reference/formats/dot-strings-files) e [`.resx`](/docs/cli/reference/formats/resx-files) vengono passati alla traduzione come contesto.
* **Terminologia e tono condivisi.** I [gruppi di contesto](/docs/platform/dashboard/guides/defining-context-for-translations) contengono un Glossario e dei Prompt Personalizzati e li applicano a ogni progetto a cui li assegni. Creane uno da un progetto con **Autogenerate from project files** per generare una bozza di termini e prompt a partire dai testi esistenti; un agente di programmazione può poi aggiornarli tramite il [server MCP](/docs/overview/for-coding-agents#mcp) di General Translation.

Per un catalogo basato su chiavi, la stessa istruzione sulla mappa dei posti va inserita accanto al file sorgente. Con questi due file puoi mantenere la chiave e la libreria esistenti:

```json title="locales/en.json"
{
  "seatStatus": "Free"
}
```

```json title="locales/en.metadata.json"
{
  "seatStatus": {
    "context": "Seat map. Free means the seat is available, not that it costs nothing.",
    "maxChars": 12
  }
}
```

## Come capire se il contesto è sufficiente?

Raccogli i pulsanti di una sola parola, le parole con più significati, le frasi con variabili e i plurali. Traducili nelle lingue previste per il lancio e falli controllare nella [Dashboard](/kb/review-translations) da qualcuno che conosca ciascuna lingua. Correggi lì il testo attuale, poi aggiungi le informazioni mancanti nel punto giusto: una nota `context` per quella stringa, oppure un termine del Glossario o un Prompt Personalizzato se il problema rischia di ripresentarsi. Le istruzioni aggiornate orientano le generazioni successive, ma non riscrivono da sole le traduzioni già salvate. La [guida sull&#39;accuratezza della traduzione con IA](/kb/is-ai-translation-accurate) spiega come impostare una valutazione più completa.

## Punti chiave

* Tieni ogni messaggio insieme ai suoi segnaposto, che tu lo scriva in JSX o sotto una chiave del catalogo.
* General Translation porta nella generazione la struttura marcata e le note esplicite; le righe sorgente opt-in e i gruppi di contesto condivisi aggiungono significato che va oltre il messaggio stesso.
* Correggi l&#39;output esistente e migliora le istruzioni per le traduzioni future. Verifica il significato e il layout separatamente.

## Related questions

- [Come mantenere coerente la terminologia nella traduzione con l'AI?](https://generaltranslation.com/it/kb/ai-translation-glossary.mdx): Mantieni un unico glossario di termini approvati, compresi i nomi da lasciare non tradotti, applicalo a ogni richiesta di traduzione, escludi variabili e codice dalla traduzione e sottoponi il risultato a revisione. General Translation lo fa con i Gruppi di contesto, il cui Glossario e i cui Prompt personalizzati si applicano a ogni progetto a cui li assegni, e con il componente Var per i valori che non vanno mai tradotti.
- [La traduzione con l'IA è abbastanza accurata per un'app in produzione?](https://generaltranslation.com/it/kb/is-ai-translation-accurate.mdx): Spesso sì, per le lingue più diffuse, ma solo dopo aver superato una valutazione sulle tue lingue, sulle tue stringhe di UI e sui contenuti più a rischio. Al WMT25, Gemini 2.5 Pro ha eguagliato o superato le traduzioni umane di riferimento in 10 coppie linguistiche su 16, ma un benchmark sui documenti non dice se brevi stringhe di interfaccia siano pronte per il rilascio.
- [Come si traduce il testo condizionale in JSX?](https://generaltranslation.com/it/kb/translate-conditional-jsx.mdx): Mantieni la frase intera e traducine ogni versione, perché un operatore ternario la spezza in frammenti che perdono il loro significato e la loro posizione nell'ordine delle parole di ciascuna lingua. General Translation lo fa con `<Branch>` all'interno di `<T>`, che traduce la frase come un'unica unità.
- [È possibile localizzare un software senza traduttori o un team di localizzazione?](https://generaltranslation.com/it/kb/localize-without-translators.mdx): Sì, è possibile localizzare senza un team di traduzione dedicato. General Translation genera i testi nuovi e modificati durante la build sfruttando il contesto del codice e una terminologia condivisa, mentre Locadex può contrassegnare i nuovi testi in React e Next.js. Colleghi bilingui o revisori freelance correggono la formulazione nella Dashboard, senza tariffe per postazione. Definisci i requisiti di revisione in base alla lingua e al costo di un errore.
- [Come assegnare i nomi alle chiavi di traduzione i18n?](https://generaltranslation.com/it/kb/i18n-key-naming.mdx): Assegna i nomi alle chiavi in base a dove compare il testo e a cosa significa, ad esempio checkout.summary.title, e non in base alla formulazione inglese. Dai a ogni uso distinto una chiave propria, anche quando il testo inglese è identico: in tedesco il pulsante Open diventa Öffnen, mentre lo stato Open diventa Offen.

## Previous and next questions

- Previous question: [Qual è il miglior strumento di localizzazione continua per i team che rilasciano ogni giorno?](https://generaltranslation.com/it/kb/best-continuous-localization-tools.mdx)
- Next question: [È possibile localizzare un software senza traduttori o un team di localizzazione?](https://generaltranslation.com/it/kb/localize-without-translators.mdx)

## Sitemap

See the [Knowledge Base sitemap](https://generaltranslation.com/it/kb/sitemap.md) for every article.
