Fournisseurs de traduction - Lingo.dev Compiler

@lingo.dev/compiler prend en charge plusieurs fournisseurs de traduction : utilisez Lingo.dev Engine pour une expérience optimale, ou connectez-vous directement aux fournisseurs LLM.

Lingo.dev Engine (recommandé)

Lingo.dev Engine est la solution la plus simple et la plus puissante pour traduire votre application. Elle offre :

Sélection dynamique de modèle : sélectionne automatiquement le meilleur modèle pour chaque paire de langues
Basculements automatisés : bascule vers des modèles de secours en cas d'échec du modèle principal
Mémoire de traduction : prend en compte les traductions passées pour garantir la cohérence
Prise en charge du glossaire : maintient la terminologie spécifique au domaine
Optimisation des coûts : utilise des modèles efficaces lorsque cela est approprié

Configuration

Inscrivez-vous sur lingo.dev
Authentifiez-vous :
```
npx lingo.dev@latest login
```
Configurez :
```
{
  models: "lingo.dev"
}
```

Tarification : forfait Hobby gratuit disponible. Suffisant pour la plupart des projets.

Clé API manuelle

Si l'authentification par navigateur échoue (par exemple, navigateur Brave bloquant), ajoutez la clé API à .env :

LINGODOTDEV_API_KEY=your_key_here

Retrouvez votre clé API dans les paramètres du projet sur lingo.dev.

Fournisseurs LLM directs

Connectez-vous directement aux fournisseurs LLM pour un contrôle total sur la sélection des modèles et les coûts.

Fournisseurs pris en charge

Fournisseur	Format de chaîne de modèle	Variable d'environnement	Obtenir une clé API
OpenAI	`openai:gpt-4o`	`OPENAI_API_KEY`	platform.openai.com
Anthropic	`anthropic:claude-3-5-sonnet`	`ANTHROPIC_API_KEY`	console.anthropic.com
Google	`google:gemini-2.0-flash`	`GOOGLE_API_KEY`	ai.google.dev
Groq	`groq:llama-3.3-70b-versatile`	`GROQ_API_KEY`	console.groq.com
Mistral	`mistral:mistral-large`	`MISTRAL_API_KEY`	console.mistral.ai
OpenRouter	`openrouter:anthropic/claude-3.5-sonnet`	`OPENROUTER_API_KEY`	openrouter.ai
Ollama	`ollama:llama3.2`	(aucune)	ollama.com (local)

Configuration simple

Utilisez un seul fournisseur pour toutes les traductions :

{
  models: {
    "*:*": "groq:llama-3.3-70b-versatile"
  }
}

Mappage par paire de locales

Utilisez différents fournisseurs pour différentes paires de langues :

{
  models: {
    // Specific pairs
    "en:es": "groq:llama-3.3-70b-versatile",    // Fast & cheap for Spanish
    "en:de": "google:gemini-2.0-flash",         // Good quality for German
    "en:ja": "openai:gpt-4o",                   // High quality for Japanese

    // Wildcards
    "*:fr": "anthropic:claude-3-5-sonnet",      // All sources → French
    "en:*": "google:gemini-2.0-flash",          // English → all targets

    // Fallback
    "*:*": "lingo.dev",                         // Everything else
  }
}

Priorité de correspondance des motifs :

Correspondance exacte ("en:es")
Joker source ("*:es")
Joker cible ("en:*")
Joker global ("*:*")

Configuration de la clé API

Ajoutez les clés API des fournisseurs dans .env :

# Lingo.dev Engine
LINGODOTDEV_API_KEY=your_key

# OpenAI
OPENAI_API_KEY=sk-...

# Anthropic
ANTHROPIC_API_KEY=sk-ant-...

# Google
GOOGLE_API_KEY=...

# Groq
GROQ_API_KEY=gsk_...

# Mistral
MISTRAL_API_KEY=...

# OpenRouter
OPENROUTER_API_KEY=sk-or-...

Ne commitez jamais les fichiers .env — ajoutez-les à .gitignore.

Guide de sélection des modèles

Pour le développement

Utilisez le pseudotraducteur — instantané, gratuit, sans clés API :

{
  dev: {
    usePseudotranslator: true,
  }
}

Pour les projets à budget limité

Groq - Inférence rapide, niveau gratuit généreux :

{
  models: {
    "*:*": "groq:llama-3.3-70b-versatile",
  }
}

Google Gemini - Tarification compétitive, bonne qualité :

{
  models: {
    "*:*": "google:gemini-2.0-flash",
  }
}

Pour une haute qualité

OpenAI GPT-4 - Meilleure qualité globale :

{
  models: {
    "*:*": "openai:gpt-4o",
  }
}

Anthropic Claude - Excellent pour les traductions nuancées :

{
  models: {
    "*:*": "anthropic:claude-3-5-sonnet",
  }
}

Pour une utilisation locale/hors ligne

Ollama - Exécutez des modèles localement :

{
  models: {
    "*:*": "ollama:llama3.2",
  }
}

Installez Ollama et téléchargez un modèle :

curl -fsSL https://ollama.com/install.sh | sh
ollama pull llama3.2

Stratégie mixte (recommandée)

Optimisez les coûts en utilisant différents modèles par langue :

{
  models: {
    // Fast & cheap for Romance languages
    "en:es": "groq:llama-3.3-70b-versatile",
    "en:fr": "groq:llama-3.3-70b-versatile",
    "en:pt": "groq:llama-3.3-70b-versatile",

    // Higher quality for complex languages
    "en:ja": "openai:gpt-4o",
    "en:zh": "openai:gpt-4o",
    "en:ar": "openai:gpt-4o",

    // Good balance for European languages
    "en:de": "google:gemini-2.0-flash",
    "en:nl": "google:gemini-2.0-flash",

    // Fallback
    "*:*": "lingo.dev",
  }
}

Instructions de traduction personnalisées

Personnalisez l'instruction de traduction envoyée aux LLM :

{
  models: "lingo.dev",
  prompt: `Translate from {SOURCE_LOCALE} to {TARGET_LOCALE}.

Guidelines:
- Use a professional tone
- Preserve all technical terms
- Do not translate brand names
- Maintain formatting (bold, italic, etc.)
- Use gender-neutral language where possible`
}

Espaces réservés disponibles :

{SOURCE_LOCALE} : code de la locale source (par ex., "en")
{TARGET_LOCALE} : code de la locale cible (par ex., "es")

Le compilateur ajoute automatiquement le contexte du texte à traduire (fichier, composant, éléments environnants).

Modèles spécifiques aux fournisseurs

OpenAI

"openai:gpt-4o"              // Best quality
"openai:gpt-4o-mini"         // Faster, cheaper
"openai:gpt-4-turbo"         // Previous generation

Anthropic

"anthropic:claude-3-5-sonnet"  // Best quality
"anthropic:claude-3-haiku"     // Faster, cheaper
"anthropic:claude-3-opus"      // Highest quality (expensive)

Google

"google:gemini-2.0-flash"      // Fast, efficient
"google:gemini-1.5-pro"        // Higher quality

Groq

"groq:llama-3.3-70b-versatile"  // Fast inference
"groq:mixtral-8x7b-32768"       // Good quality

Mistral

"mistral:mistral-large"         // Best quality
"mistral:mistral-small"         // Faster, cheaper

OpenRouter

OpenRouter fournit un accès à plus de 100 modèles. Utilisez les identifiants de modèle depuis openrouter.ai/models :

"openrouter:anthropic/claude-3.5-sonnet"
"openrouter:google/gemini-2.0-flash"
"openrouter:meta-llama/llama-3.3-70b"

Ollama

Utilisez n'importe quel modèle Ollama :

"ollama:llama3.2"
"ollama:mistral"
"ollama:qwen2.5"

Listez les modèles disponibles : ollama list

Fournisseurs compatibles OpenAI

Vous pouvez utiliser n'importe quelle API compatible OpenAI en configurant OPENAI_BASE_URL pour pointer vers le endpoint du fournisseur. Cela fonctionne avec des fournisseurs comme Nebius, Together AI et Fireworks.

Remarque Nebius est le seul fournisseur compatible OpenAI officiellement testé avec le compilateur Lingo.dev. Les autres fournisseurs listés ci-dessous exposent des API compatibles OpenAI mais ne sont pas officiellement testés.

Configuration

Définissez les variables d'environnement :

OPENAI_API_KEY=<your-provider-api-key>
OPENAI_BASE_URL=<provider-api-endpoint>

Utilisez le préfixe openai: avec l'ID du modèle du fournisseur :

{
  models: {
    "*:*": "openai:provider-model-id"
  }
}

Fournisseurs pris en charge

Fournisseur	URL de base	Exemple de modèle
Nebius	`https://api.tokenfactory.nebius.com/v1`	`google/gemma-2-9b-it-fast`
Together AI	`https://api.together.xyz/v1`	`meta-llama/Llama-3-70b-chat-hf`
Fireworks	`https://api.fireworks.ai/inference/v1`	`accounts/fireworks/models/llama-v3-70b-instruct`

Les exemples de modèles sont illustratifs. La disponibilité et les ID de modèles peuvent changer au fil du temps. Vérifiez toujours la liste actuelle des modèles auprès de l'API du fournisseur.

Questions fréquentes

Quel fournisseur dois-je utiliser ? Commencez avec Lingo.dev Engine pour plus de simplicité. Pour un contrôle total et une optimisation des coûts, utilisez le mapping de paires de locales avec plusieurs fournisseurs.

Ai-je besoin de clés API en production ? Non. Utilisez buildMode: "cache-only" en production — les traductions sont pré-générées. Voir Modes de build.

Puis-je combiner plusieurs fournisseurs ? Oui. Utilisez le mapping de paires de locales pour router différentes paires de langues vers différents fournisseurs.

Que se passe-t-il si ma clé API est invalide ? Le compilateur échouera avec un message d'erreur clair. Vérifiez votre fichier .env et assurez-vous que la clé API est correcte pour le fournisseur configuré.

Puis-je utiliser des modèles personnalisés ? OpenRouter prend en charge plus de 100 modèles. Ollama prend en charge tout modèle installé localement. Les autres fournisseurs sont limités à leur catalogue de modèles.

Comment tester sans appels API ? Activez le pseudotraducteur en développement :

{
  dev: { usePseudotranslator: true }
}

Quelle est la différence de coût entre les fournisseurs ? Varie considérablement. Groq offre un niveau gratuit généreux. OpenAI GPT-4 a une tarification premium. Google Gemini est à un prix compétitif. Consultez la page de tarification de chaque fournisseur.

Prochaines étapes

Modes de compilation — Optimiser pour le développement ou la production
Référence de configuration — Toutes les options de configuration
Bonnes pratiques — Stratégies recommandées pour les fournisseurs