LibreTranslate
Pruébalo en línea! | Documentación de la API | Foro de la Comunidad | Bluesky
API de traducción automática gratuita y de código abierto, completamente alojada en el propio servidor. A diferencia de otras API, no depende de proveedores propietarios como Google o Azure para realizar las traducciones. En su lugar, su motor de traducción se basa en código abierto. Argos Translate libreria.
Pruébalo en línea! | Documentación de la API
Ejemplos de la API
Básico
Solicitud:
const res = await fetch("https://libretranslate.com/translate", {
method: "POST",
body: JSON.stringify({
q: "Hello!",
source: "en",
target: "es",
}),
headers: { "Content-Type": "application/json" },
});
console.log(await res.json());
Respuesta:
{
"translatedText": "¡Hola!"
}
Lista de códigos de idiomas: https://libretranslate.com/languages
Detección automática de idioma
Solicitud:
const res = await fetch("https://libretranslate.com/translate", {
method: "POST",
body: JSON.stringify({
q: "Ciao!",
source: "auto",
target: "es",
}),
headers: { "Content-Type": "application/json" },
});
console.log(await res.json());
Respuesta:
{
"detectedLanguage": {
"confidence": 83,
"language": "it"
},
"translatedText": "Adios!"
}
HTML
Solicitud:
const res = await fetch("https://libretranslate.com/translate", {
method: "POST",
body: JSON.stringify({
q: '<p class="green">Hello!</p>',
source: "en",
target: "es",
format: "html",
}),
headers: { "Content-Type": "application/json" },
});
console.log(await res.json());
Respuesta:
{
"translatedText": "<p class=\"green\">¡Hola!</p>"
}
Traducciones Alternativas
Solicitud:
const res = await fetch("https://libretranslate.com/translate", {
method: "POST",
body: JSON.stringify({
q: "Hello",
source: "en",
target: "it",
format: "text",
alternatives: 3,
}),
headers: { "Content-Type": "application/json" },
});
console.log(await res.json());
Respuesta:
{
"alternatives": [
"Salve",
"Pronto"
],
"translatedText": "Ciao"
}
Instalar y Ejecutar
Puedes ejecutar tu propio servidor API con solo unas pocas líneas de configuración!
Asegúrate de tener instalado Python (se recomienda la versión 3.8 o superior) y, a continuación, simplemente ejecuta:
pip install libretranslate
libretranslate [args]
Luego abra un navegador web para http://localhost:5000
De forma predeterminada, LibreTranslate instalará compatibilidad con todos los idiomas disponibles. Para cargar solo ciertos idiomas y reducir el tiempo de inicio, puede usar el argumento --load-only:
libretranslate --load-only en,es,fr
Consulte también los demás arguments a continuación.
En Ubuntu 20.04, también puede usar el script de instalación disponible en https://github.com/argosopentech/LibreTranslate-init
Ejecutar con Docker
También puede ejecutar la aplicación con docker:
Linux/macOS
./run.sh [args]
Windows
run.bat [args]
Compilación y ejecución
Consulta CONTRIBUTING.md para obtener información sobre cómo compilar y ejecutar el proyecto tú mismo.
CUDA
Puedes usar la aceleración por hardware para acelerar las traducciones en un equipo con GPU con CUDA 12.4.1 y nvidia-docker instalados.
Ejecuta esta versión con:
docker compose -f docker-compose.cuda.yml up -d --build
Argumentos
Los argumentos que se pasan al proceso o se configuran mediante variables de entorno se dividen en dos tipos.
-
Ajustes o indicadores de tiempo de ejecución que se utilizan para alternar modos de ejecución específicos o deshabilitar partes de la aplicación. Actúan como un interruptor al agregarse o eliminarse.
-
Parámetros de configuración para establecer varios límites y configurar la aplicación. Estos requieren que se pase un parámetro para funcionar. Si se eliminan, se utilizan los parámetros predeterminados.
Configuración / Indicadores
| Argumento | Descripción | Configuración predeterminada | Sobre nombre |
|---|---|---|---|
| --debug | Habilitar entorno de depuración | Desactivado |
LT_DEBUG |
| --ssl | Si habilitar SSL | Desactivado |
LT_SSL |
| --api-keys | Habilitar la base de datos de claves API para los límites de velocidad por cliente cuando se alcanza --req-limit | No utilice claves API |
LT_API_KEYS |
| --require-api-key-origin | Requerir el uso de una clave API para el acceso programático a la API, a menos que el origen de la solicitud coincida con este dominio | Sin restricciones sobre el origen del dominio |
LT_REQUIRE_API_KEY_ORIGIN |
| --require-api-key-secret | Requerir el uso de una clave API para el acceso programático a la API, a menos que el cliente también envíe una coincidencia secreta | No se requieren secretos |
LT_REQUIRE_API_KEY_SECRET |
| --require-api-key-fingerprint | Requerir el uso de una clave API para el acceso programático a la API, a menos que el cliente también coincida con una huella digital | No se requieren huellas digitales |
LT_REQUIRE_API_KEY_FINGERPRINT |
| --under-attack | Habilitar el modo bajo ataque. Cuando está habilitado, las solicitudes deben realizarse con una clave API. | Desactivado |
LT_UNDER_ATTACK |
| --suggestions | Permitir sugerencias de usuarios | Desactivado |
LT_SUGGESTIONS |
| --disable-files-translation | Deshabilitar la traducción de archivos | Se permite la traducción de archivos |
LT_DISABLE_FILES_TRANSLATION |
| --disable-web-ui | Deshabilitar la interfaz web | Interfaz de usuario web habilitada |
LT_DISABLE_WEB_UI |
| --update-models | Actualizar los modelos de lenguaje al inicio | Solo se activa si no se encuentran modelos |
LT_UPDATE_MODELS |
| --metrics | Habilitar el punto final /metrics para exportar Prometheus métricas de uso | Desactivado |
LT_METRICS |
Parámetros de configuración
| Argumento | Descripción | Parámetro predeterminado | Sobre nombre |
|---|---|---|---|
| --host | Establecer el host para vincular el servidor to | 127.0.0.1 |
LT_HOST |
| --port | Establecer el puerto al que se vinculará el servidor | 5000 |
LT_PORT |
| --char-limit | Establecer límite de caracteres | Sin Limite |
LT_CHAR_LIMIT |
| --req-limit | Establecer el número máximo de solicitudes por minuto por cliente (fuera de los límites establecidos por las claves API) | Sin Limite |
LT_REQ_LIMIT |
| --req-limit-storage | URI de almacenamiento para limitar el almacenamiento de datos de solicitudes. Ver Flask Limiter | memoria:// |
LT_REQ_LIMIT_STORAGE |
| --req-time-cost | Considera el coste de tiempo (en segundos) para limitar las solicitudes. Si una solicitud tarda 10 segundos y este valor se establece en 5, el coste de la solicitud es 2 o el coste real de la solicitud (el que sea mayor). | Sin costo de tiempo |
LT_REQ_TIME_COST |
| --batch-limit | Establecer el número máximo de textos a traducir en una solicitud por lotes | Sin Limite |
LT_BATCH_LIMIT |
| --ga-id | Habilite Google Analytics en la página del cliente API proporcionando una identificación | Vacío (sin seguimiento) |
LT_GA_ID |
| --frontend-language-source | Establecer el idioma predeterminado del frontend - fuente | auto |
LT_FRONTEND_LANGUAGE_SOURCE |
| --frontend-language-target | Establecer el idioma predeterminado del frontend - objetivo | locale (coincide con la configuración regional del sitio) |
LT_FRONTEND_LANGUAGE_TARGET |
| --frontend-timeout | Establecer el tiempo de espera de traducción del frontend | 500 |
LT_FRONTEND_TIMEOUT |
| --api-keys-db-path | Utilice una ruta específica dentro del contenedor para la base de datos local. Puede ser absoluta o relativa. | db/api_keys.db |
LT_API_KEYS_DB_PATH |
| --api-keys-remote | Utilice este punto final remoto para consultar claves API válidas en lugar de utilizar la base de datos local | Vacío (usa db local en su lugar) |
LT_API_KEYS_REMOTE |
| --get-api-key-link | Mostrar un enlace en la interfaz de usuario donde dirigir a los usuarios para obtener una clave API | Vacío (no se muestra ningún enlace en la interfaz web) |
LT_GET_API_KEY_LINK |
| --shared-storage | URI de almacenamiento compartido que se utilizará para compartir datos entre múltiples procesos (por ejemplo, al usar gunicorn) | memoria:// |
LT_SHARED_STORAGE |
| --secondary | Marque esta instancia como una instancia secundaria para evitar conflictos con el nodo principal en configuraciones de múltiples nodos | Nodo primario |
LT_SECONDARY |
| --load-only | Establecer idiomas disponibles | Vacío (utilizar todo de argostranslate) |
LT_LOAD_ONLY |
| --threads | Establecer número de subprocesos | 4 |
LT_THREADS |
| --metrics-auth-token | Proteja el punto final /metrics permitiendo solo clientes que tengan un token de portador de autorización válido | Vacío (no se requiere autenticación) |
LT_METRICS_AUTH_TOKEN |
| --url-prefix | Agregar prefijo a la URL: ejemplo.com:5000/prefijo-url/ | / |
LT_URL_PREFIX |
Notas:
-
Cada argumento tiene una variable de entorno equivalente que puede usarse en su lugar. Las variables de entorno sobrescriben los valores predeterminados, pero tienen menor prioridad que los argumentos del comando y son especialmente útiles si se usan con Docker. Los nombres de las variables de entorno son la versión en mayúsculas del nombre del argumento del comando equivalente, con el prefijo
LT. -
Para configurar el requisito de uso de la clave API, establezca
--req-limiten0y agregue el indicador--api-keys. Las solicitudes realizadas sin una clave API correcta serán rechazadas. -
Al establecer
--update-models, se actualizarán los modelos independientemente de si hay actualizaciones disponibles.
Actualización
Software
Si instaló con pip:
pip install -U libretranslate
Si usa docker:
docker pull libretranslate/libretranslate
Modelos de lenguaje
Inicie el programa con el argumento --update-models. Por ejemplo: libretranslate --update-models o ./run.sh --update-models.
También puede ejecutar el script scripts/install_models.py.
Ejecutar con WSGI y Gunicorn
pip install gunicorn
gunicorn --bind 0.0.0.0:5000 'wsgi:app'
Puedes pasar los argumentos de la aplicación directamente a Gunicorn mediante:
gunicorn --bind 0.0.0.0:5000 'wsgi:app(api_keys=True)'
Implementación de Kubernetes
Consulta el artículo Mediano de JM Robles y el k8s.yaml mejorado por @rasos.
Gráfico de Helm
Gracias al trabajo de @rasos, ahora puedes instalar LibreTranslate en Kubernetes usando Helm.
Ya hay un gráfico de Helm disponible en el repositorio helm-chart, donde puedes encontrar más detalles.
Puede instalar rápidamente LibreTranslate en Kubernetes usando Helm con el siguiente comando:
helm repo add libretranslate https://libretranslate.github.io/helm-chart/
helm repo update
helm search repo libretranslate
helm install libretranslate libretranslate/libretranslate --namespace libretranslate --create-namespace
Administrar claves API
LibreTranslate admite cuotas límite por usuario. Por ejemplo, puede emitir claves API a los usuarios para que puedan disfrutar de mayores límites de solicitudes por minuto (si también configura --req-limit). De forma predeterminada, todos los usuarios tienen un límite de velocidad basado en --req-limit, pero al pasar un parámetro opcional api_key a los endpoints REST, un usuario puede disfrutar de mayores límites de solicitudes. También puede especificar diferentes límites de caracteres que omiten el valor predeterminado --char-limit por clave.
Para usar claves API, simplemente inicie LibreTranslate con la opción --api-keys. Si modificó la ruta de la base de datos de claves API con la opción --api-keys-db-path, debe especificar la ruta con el mismo indicador de argumento al usar el comando ltmanage keys.
Agregar nuevas claves
Para emitir una nueva clave API con un límite de 120 solicitudes por minuto:
ltmanage keys add 120
Para emitir una nueva clave API con 120 solicitudes por minuto y un máximo de 5000 caracteres por solicitud:
ltmanage keys add 120 --char-limit 5000
Si cambió la ruta de la base de datos de claves API:
ltmanage keys --api-keys-db-path path/to/db/dbName.db add 120
Eliminar claves
ltmanage keys remove <api-key>
Ver claves
ltmanage keys
Métricas de Prometheus
LibreTranslate tiene Prometheus Capacidades de exportador cuando pasa el argumento --metrics al inicio (deshabilitado de manera predeterminada). Cuando las métricas están habilitadas, se monta un punto final /metrics en la instancia:
# HELP libretranslate_http_requests_in_flight Métrica multiproceso
# TYPE libretranslate_http_requests_in_flight Indicador
libretranslate_http_requests_in_flight{api_key="",endpoint="/translate",request_ip="127.0.0.1"} 0.0
# HELP libretranslate_http_request_duration_seconds Métrica multiproceso
# TYPE libretranslate_http_request_duration_seconds Resumen
libretranslate_http_request_duration_seconds_count{api_key="",endpoint="/translate",request_ip="127.0.0.1",status="200"} 0.0
libretranslate_http_request_duration_seconds_sum{api_key="",endpoint="/translate",request_ip="127.0.0.1",status="200"} 0.0
Puede configurar prometheus.yml para leer las métricas:
scrape_configs:
- job_name: "libretranslate"
# Solo es necesario si usas --metrics-auth-token
#authorization:
#credentials: "mytoken"
static_configs:
- targets: ["localhost:5000"]
Para proteger el endpoint /metrics, también puedes usar --metrics-auth-token mytoken.
Si usa Gunicorn, asegúrese de crear un directorio para almacenar las métricas de datos multiproceso y configure PROMETHEUS_MULTIPROC_DIR:
mkdir -p /tmp/prometheus_data
rm /tmp/prometheus_data/*
export PROMETHEUS_MULTIPROC_DIR=/tmp/prometheus_data
gunicorn -c scripts/gunicorn_conf.py --bind 0.0.0.0:5000 'wsgi:app(metrics=True)'
Enlaces de lenguaje
Puedes usar el plugin oficial de traducción de Discourse para traducir temas de Discourse con LibreTranslate. Para instalarlo, simplemente modifica /var/discourse/containers/app.yml:
## Los plugins van aquí
## Consulta https://meta.discourse.org/t/19157 para más detalles
hooks:
after_code:
- exec:
cd: $home/plugins
cmd:
- git clone https://github.com/discourse/docker_manager.git
- git clone https://github.com/discourse/discourse-translator
...
Luego, ejecuta ./launcher rebuild app. Desde el panel de administración de Discourse, selecciona "LibreTranslate" como proveedor de traducción y configura los endpoints correspondientes.
Véalo en acción en esta página.
Aplicaciones móviles
- LibreTranslator es una aplicación para Android disponible en Play Store y en la tienda de F-Droid que utiliza la API de LibreTranslate.
- Translate You es una aplicación de traducción centrada en la privacidad, desarrollada con MD3, disponible en la tienda de F-Droid y que utiliza la API de LibreTranslate, entre otros proveedores. - LiTranslate es una aplicación para iOS disponible en la App Store que utiliza la API de LibreTranslate.
Navegador web
- minbrowser es un navegador web con soporte integrado para LibreTranslate.
- Un complemento de LibreTranslate para Firefox está actualmente en desarrollo.
Espejos
Esta es una lista de instancias públicas de LibreTranslate; algunas requieren una clave API. Si desea agregar una nueva URL, abra una solicitud de extracción.
| URL | Se requiere clave API | Enlaces |
|---|---|---|
| libretranslate.com | ✔️ | [ Get API Key ] [ Service Status ] |
| translate.flossboxin.org.in | [ Contact/eMail ] | |
| lt.blitzw.in |
TOR/i2p Espejos
| URL |
|---|
| lt.vernccvbvyi5qhfzyqengccj7lkove6bjot2xhh5kajhwvidqafczrad.onion |
| lt.vern.i2p |
Añadiendo nuevos modelos de lenguaje
Tiene dos opciones para crear nuevos modelos de lenguaje:
La mayoría de los datos de entrenamiento provienen de Opus, un corpus paralelo de código abierto. Consulte también NLLU
Localización
La interfaz web de LibreTranslate está disponible en todos los idiomas a los que LibreTranslate puede traducir. También puede (aproximadamente) traducirse a sí mismo!. Es posible que algunos idiomas no aparezcan en la interfaz de usuario, ya que aún no han sido revisados por un usuario. Puedes habilitar todos los idiomas activando el modo --debug.
Para ayudar a mejorar o revisar las traducciones de la interfaz de usuario:
- Ve a https://hosted.weblate.org/projects/libretranslate/app/#translations. Todos los cambios se envían automáticamente a este repositorio.
- Una vez revisadas/editadas todas las cadenas, abre una solicitud de extracción y modifica
libretranslate/locales/{code}/meta.json:
{
"name": "<Idioma>",
"reviewed": true <-- Cambia esto de falso a verdadero
}
| Idioma | Revisado | Enlace de Pizarra web |
|---|---|---|
| Arabic | Edit | |
| Azerbaijani | Edit | |
| Basque | ✔️ | Edit |
| Chinese | ✔️ | Edit |
| Chinese (Traditional) | Edit | |
| Czech | ✔️ | Edit |
| Danish | Edit | |
| Dutch | Edit | |
| English | ✔️ | Edit |
| Esperanto | ✔️ | Edit |
| Finnish | Edit | |
| French | ✔️ | Edit |
| German | ✔️ | Edit |
| Greek | Edit | |
| Hebrew | Edit | |
| Hindi | Edit | |
| Hungarian | Edit | |
| Indonesian | Edit | |
| Irish | Edit | |
| Italian | ✔️ | Edit |
| Japanese | Edit | |
| Kabyle | ✔️ | Edit |
| Korean | ✔️ | Edit |
| Occitan | Edit | |
| Persian | Edit | |
| Polish | Edit | |
| Portuguese | ✔️ | Edit |
| Russian | ✔️ | Edit |
| Slovak | Edit | |
| Spanish | ✔️ | Edit |
| Swedish | Edit | |
| Turkish | Edit | |
| Ukrainian | ✔️ | Edit |
| Vietnamese | Edit |
Mapa de ruta
Ayúdanos abriendo una solicitud de extracción!
- Enlaces de lenguaje para cada lenguaje de programación
- Traducciones mejoradas
Cualquier otra idea es bienvenida.
Preguntas frecuentes
Puedo usar su servidor API en libretranslate.com para mi aplicación en producción?
En resumen, sí, pero solo si compras una clave API. Por supuesto, siempre puedes ejecutar LibreTranslate gratis en tu propio servidor.
Algunas traducciones en libretranslate.com son diferentes a las alojadas por el usuario. Por qué?
Por defecto, los modelos de lenguaje se cargan desde el argos-index. A veces implementamos modelos en libretranslate.com que aún no se han añadido al índice argos, como los convertidos desde OPUS (thread)
Dónde se guardan los modelos de lenguaje?
En $HOME/.local/share/argos-translate/packages. En Windows, es C:\Users\youruser\.local\share\argos-translate\packages.
Puedo usar LibreTranslate tras un proxy inverso, como Apache2 o Caddy?
Sí, aquí hay ejemplos de configuración para Apache2 y Caddy que redirigen un subdominio (con certificado HTTPS) a LibreTranslate ejecutándose en un contenedor en el host local.
sudo docker run -ti --rm -p 127.0.0.1:5000:5000 libretranslate/libretranslate
Puede eliminar 127.0.0.1 del comando anterior si desea acceder a él desde domain.tld:5000, además de subdomain.domain.tld (esto puede ser útil para determinar si hay un problema con Apache 2 o el contenedor de Docker).
Agregue --restart unless-stopped si desea que este contenedor se inicie al arrancar, a menos que se detenga manualmente.
Configuración de Apache
Reemplace [YOUR_DOMAIN] con su dominio completo; por ejemplo, translate.domain.tld o libretranslate.domain.tld.
Elimine # en las líneas ErrorLog y CustomLog para registrar las solicitudes.
#Libretranslate
#Redireccionar http a https
<VirtualHost *:80>
Nombre del servidor http://[SU_DOMINIO]
Redirigir / https://[SU_DOMINIO]
# Registro de errores ${APACHE_LOG_DIR}/error.log
# Registro personalizado ${APACHE_LOG_DIR}/tr-access.log combinado
</VirtualHost>
#https
<HostVirtual *:443>
NombreDeServidor https://[SU_DOMINIO]
PassProxy / http://127.0.0.1:5000/
PassReverseProxy / http://127.0.0.1:5000/
ProxyPreserveHost Activado
SSLEngine Activado
ArchivoDeCertificadoSSL /etc/letsencrypt/live/[SU_DOMINIO]/fullchain.pem
ArchivoDeClaveDeCertificadoSSL /etc/letsencrypt/live/[SU_DOMINIO]/privkey.pem
ArchivoDeCadenaDeCertificadoSSL /etc/letsencrypt/live/[SU_DOMINIO]/fullchain.pem
# RegistroDeErrores ${APACHE_LOG_DIR}/tr-error.log
# RegistroPersonalizado ${APACHE_LOG_DIR}/tr-access.log Combinado
</VirtualHost>
Agregue esto a la configuración de un sitio existente o a un nuevo archivo en /etc/apache2/sites-available/new-site.conf y ejecute sudo a2ensite new-site.conf.
Para obtener un certificado de subdominio HTTPS, instale certbot (snap), ejecute sudo certbot certonly --manual --preferred-challenges dns e ingrese su información (con subdomain.domain.tld como dominio). Agregue un registro DNS TXT con su registrador de dominio cuando se le solicite. Esto guardará su certificado y clave en /etc/letsencrypt/live/{subdomain.domain.tld}/. Como alternativa, comente las líneas SSL si no desea usar HTTPS.
Configuración de Caddy
Reemplace [SU_DOMINIO] con su dominio completo; por ejemplo, translate.domain.tld o libretranslate.domain.tld.
#Libretranslate
[SU_DOMINIO] {
reverse_proxy localhost:5000
}
Agregue esto a un archivo Caddyfile existente o guárdelo como Caddyfile en cualquier directorio y ejecute sudo caddy reload en ese mismo directorio.
NGINX config
Reemplace [SU_DOMINIO] con su dominio completo; por ejemplo, translate.domain.tld o libretranslate.domain.tld.
Elimine # en las líneas access_log y error_log para deshabilitar el registro.
server {
list 80; nombre_del_servidor [SU_DOMINIO];
return 301 https://$nombre_del_servidor$uri_de_solicitud;
}
servidor {
list 443 http2 ssl;
nombre_del_servidor [SU_DOMINIO];
#registro_acceso off;
#registro_error off;
# Sección SSL
certificado_ssl /etc/letsencrypt/live/[SU_DOMINIO]/fullchain.pem;
clave_del_certificado_ssl /etc/letsencrypt/live/[SU_DOMINIO]/privkey.pem;
protocolos_ssl TLSv1.2 TLSv1.3;
# Utilizando el conjunto de cifrado recomendado de: https://wiki.mozilla.org/Security/Server_Side_TLS
ssl_ciphers 'ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384';
ssl_session_timeout 10m;
ssl_session_cache shared:MozSSL:10m; # aproximadamente 40000 sesiones
ssl_session_tickets off;
# Especifica una curva para cifrados ECDHE.
ssl_ecdh_curve prime256v1;
# El servidor debe determinar los cifrados, no el cliente.
ssl_prefer_server_ciphers on;
# Sección de encabezado
add_header Strict-Transport-Security "max-age=31536000; includeSubDomains; preload" always;
add_header Referrer-Policy "strict-origin" always;
add_header X-Frame-Options "SAMEORIGIN" always; add_header X-XSS-Protection "1; modo=bloquear" siempre;
add_header X-Content-Type-Options "nosniff" siempre;
add_header X-Download-Options "noopen" siempre;
add_header X-Robots-Tag "none" siempre;
add_header Política de funciones "micrófono 'ninguno'; cámara 'ninguna'; geolocalización 'ninguna';" siempre;
# Encabezado más reciente, pero no compatible en todas partes
add_header Política de permisos "micrófono=(), cámara=(), geolocalización=()" siempre;
# Eliminar X-Powered-By, que es una fuga de información
fastcgi_hide_header X-Powered-By;
# No enviar el encabezado del servidor nginx
server_tokens off;
# Sección GZIP
gzip activado;
gzip_disable "msie6";
gzip_vary activado;
gzip_proxied any;
gzip_comp_level 6;
gzip_buffers 16 8k;
gzip_http_version 1.1;
gzip_min_length 256; gzip_types texto/xml texto/javascript fuente/ttf fuente/eot fuente/otf aplicación/x-javascript aplicación/atom+xml aplicación/javascript aplicación/json aplicación/manifiesto+json aplicación/rss+xml aplicación/x-web-app-manifest+json aplicación/xhtml+xml aplicación/xml imagen/svg+xml imagen/x-icon texto/css texto/plain;
location / {
proxy_pass http://127.0.0.1:5000/;
proxy_set_header Host $http_host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
client_max_body_size 0;
}
}
Agregue esto a una configuración de NGINX existente o guárdelo como libretranslate en el directorio /etc/nginx/site-enabled y ejecute sudo nginx -s reload.
Puedo ejecutarlo como systemd (el instalado por defecto en pip/python)?
Sí, simplemente cree un archivo de servicio en /etc/systemd/system y habilítelo para que se ejecute al inicio.
El archivo .env (entorno) es opcional según su configuración. Agregue lo siguiente al archivo (modifique los valores según sea necesario) y nómbrelo "libretranslate.service).
[Unidad]
Descripción=LibreTranslate
Después=network.target
[Servicio]
Usuario=root
Tipo=idle
Reiniciar=always
Environment="PATH=/usr/local/lib/python3.11/dist-packages/libretranslate"
ExecStart=/usr/bin/python3 /usr/local/bin/libretranslate
EnvironmentFile=/usr/local/lib/python3.11/dist-packages/libretranslate/.env
ExecReload=/bin/kill -s HUP $MAINPID
KillMode=mixed
TimeoutStopSec=1
[Instalar]
WantedBy=multi-user.target
Una vez guardado, vuelva a cargar el archivo Daemon e iniciar el servicio:
systemctl daemon-reload
systemctl start libretranslate.service
systemctl enable libretranslate.service
Puedo realizar traducciones por lotes?
Sí, pasa un array de cadenas en lugar de una cadena al campo q:
const res = await fetch("https://libretranslate.com/translate", {
method: "POST",
body: JSON.stringify({
q: ["Hello", "world"],
source: "en",
target: "es",
}),
headers: { "Content-Type": "application/json" },
});
console.log(await res.json());
// {
// "translatedText": [
// "Hola",
// "mundo"
// ]
// }
Contribuyendo
Agradecemos sus contribuciones! Aquí tienen algunas ideas:
- Entrenar un nuevo modelo de lenguaje usando Locomotive. Por ejemplo, queremos entrenar redes neuronales mejoradas para alemán y muchos otros idiomas.
- Puedes superar el rendimiento de nuestros modelos de lenguaje? Entrena uno nuevo y comparémoslo. Para enviar tu modelo, publica en el foro de la comunidad un enlace para descargar tu archivo .argosmodel y un texto de muestra que tu modelo haya traducido.
- Elige un problema en el que trabajar.
Créditos
Este trabajo es posible en gran medida gracias a Argos Translate, que impulsa el motor de traducción.
Licencia
Licencia Pública General GNU Affero v3
Marca registrada
Consulte las Directrices de marca registrada
Projectos Relacionados
- LTEngine: Machine translation powered by LLMs with a LibreTranslate-compatible API