Автоматизация перевода блога на два языка: пошаговый гайд с ChatGPT, Django и Python

Почему ручной перевод блога - это каменный век

Вы пишете пост на русском. Потом открываете Google Translate, копируете текст, правите кривой перевод, генерируете мета-теги для английской версии. Через неделю правите опечатку в оригинале и забываете поправить перевод. SEO страдает, читатели уходят, а вы тратите часы на рутину.

Есть способ проще. Я автоматизировал перевод для своего Django-блога, и теперь ИИ делает всю грязную работу. Рассказываю, как это работает в 2026 году и почему современные ИИ-переводчики уже не просто гонят лапшу.

Что у вас должно быть перед стартом

• Рабочий Django-проект с блогом (PostgreSQL предпочтительнее)
• Модель статьи с полями: title, content, slug, meta_title, meta_description
• API-ключ от OpenAI (на 2026 год актуальна модель GPT-4o для баланса цены и качества)
• Базовое понимание, как работают Django сигналы и management commands

1 Готовим Django к мультиязычности

Не нужно городить django-modeltranslation. Мы сделаем проще - отдельную модель для перевода. Зачем? Потому что когда вы отредактируете оригинал, система должна понять, что перевод устарел.

Добавляем в models.py:

from django.db import models
from django.utils.translation import gettext_lazy as _

class Article(models.Model):
    title = models.CharField(_('Заголовок'), max_length=200)
    content = models.TextField(_('Содержание'))
    slug = models.SlugField(unique=True)
    meta_title = models.CharField(max_length=60, blank=True)
    meta_description = models.CharField(max_length=160, blank=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    
    def __str__(self):
        return self.title

class ArticleTranslation(models.Model):
    LANG_CHOICES = [
        ('en', 'English'),
        ('de', 'Deutsch'),  # добавим немецкий для примера
    ]
    
    article = models.ForeignKey(Article, on_delete=models.CASCADE, related_name='translations')
    language = models.CharField(max_length=2, choices=LANG_CHOICES)
    title = models.CharField(max_length=200)
    content = models.TextField()
    meta_title = models.CharField(max_length=60, blank=True)
    meta_description = models.CharField(max_length=160, blank=True)
    is_outdated = models.BooleanField(default=False)  # флаг устаревания
    translated_at = models.DateTimeField(auto_now=True)
    
    class Meta:
        unique_together = ['article', 'language']
    
    def __str__(self):
        return f"{self.article.title} ({self.get_language_display()})"

Поле is_outdated - ключевое. Когда правите оригинальную статью, система помечает перевод как устаревший. Потом скрипт перевода обновит только устаревшие версии.

2 Интеграция ChatGPT API: не только перевод

Большинство подключает API для прямой замены текста. Ошибка. Современные LLM типа GPT-4o умеют больше - они понимают контекст и могут генерировать SEO-оптимизированные метаданные.

Установите библиотеку openai (актуальная версия на 2026 - 2.0+):

pip install openai

Создайте файл services/translator.py:

import openai
from django.conf import settings
from typing import Dict, Any
import json

openai.api_key = settings.OPENAI_API_KEY

class BlogTranslator:
    MODEL = "gpt-4o"  # на 2026 это оптимально по цене/качеству
    
    @staticmethod
    def translate_article(original_title: str, original_content: str, target_lang: str) -> Dict[str, Any]:
        """Переводит статью и генерирует метаданные."""
        
        prompt = f"""Ты профессиональный переводчик и SEO-специалист.
        Переведи статью блога с русского на {target_lang}. Сохрани стиль и термины.
        
        Также сгенерируй:
        1. Заголовок для перевода (макс 60 символов)
        2. Meta description (макс 160 символов)
        3. 5 ключевых слов для SEO
        
        Верни ответ в формате JSON:
        {{
            "translated_title": "строка",
            "translated_content": "строка",
            "meta_title": "строка",
            "meta_description": "строка",
            "keywords": ["слово1", "слово2"]
        }}
        
        Оригинальный заголовок: {original_title}
        
        Оригинальное содержание:
        {original_content[:3000]}  # обрезаем для экономии токенов
        """
        
        try:
            response = openai.chat.completions.create(
                model=BlogTranslator.MODEL,
                messages=[
                    {"role": "system", "content": "Ты переводишь технический блог. Будь точным в терминах."},
                    {"role": "user", "content": prompt}
                ],
                temperature=0.3,  # меньше креатива, больше точности
                response_format={"type": "json_object"}
            )
            
            result = json.loads(response.choices[0].message.content)
            return result
            
        except Exception as e:
            print(f"Ошибка перевода: {e}")
            # fallback - простой перевод без метаданных
            return {
                "translated_title": original_title,
                "translated_content": original_content,
                "meta_title": "",
                "meta_description": "",
                "keywords": []
            }

Температуру ставим 0.3 - нам нужна точность, не креатив. GPT-4o отлично справляется с техническими текстами, но если ваш блог про поэзию, возможно, стоит повысить до 0.5. Другие модели вроде Hunyuan-MT тоже хороши, но для интеграции с Django проще использовать OpenAI API.

3 Пишем скрипт-автомат, который не сломает блог

Management command в Django - идеальное место для такой логики. Создайте management/commands/translate_articles.py.

Как НЕ надо делать: Брать все статьи и гнать их в API подряд. Вы получите счет на $500 и блокировку за превышение лимитов.

from django.core.management.base import BaseCommand
from blog.models import Article, ArticleTranslation
from services.translator import BlogTranslator
from django.db import transaction
import time

class Command(BaseCommand):
    help = 'Переводит статьи на целевые языки'
    
    def add_arguments(self, parser):
        parser.add_argument('--lang', type=str, default='en', help='Целевой язык (en, de)')
        parser.add_argument('--limit', type=int, default=5, help='Сколько статей обработать за раз')
        parser.add_argument('--only-outdated', action='store_true', help='Переводить только устаревшие')
    
    def handle(self, *args, **options):
        target_lang = options['lang']
        limit = options['limit']
        only_outdated = options['only_outdated']
        
        # Определяем, какие статьи брать
        if only_outdated:
            articles = Article.objects.filter(
                translations__language=target_lang,
                translations__is_outdated=True
            ).distinct()[:limit]
            self.stdout.write(f'Найдено {articles.count()} устаревших переводов для {target_lang}')
        else:
            # Ищем статьи без перевода на этот язык
            articles_with_translation = Article.objects.filter(
                translations__language=target_lang
            ).values_list('id', flat=True)
            
            articles = Article.objects.exclude(
                id__in=articles_with_translation
            )[:limit]
            self.stdout.write(f'Найдено {articles.count()} статей без перевода на {target_lang}')
        
        if not articles:
            self.stdout.write('Нет статей для перевода')
            return
        
        for article in articles:
            self.stdout.write(f'Обрабатываю: {article.title}')
            
            try:
                result = BlogTranslator.translate_article(
                    article.title,
                    article.content,
                    target_lang
                )
                
                with transaction.atomic():
                    # Создаем или обновляем перевод
                    translation, created = ArticleTranslation.objects.update_or_create(
                        article=article,
                        language=target_lang,
                        defaults={
                            'title': result['translated_title'][:200],
                            'content': result['translated_content'],
                            'meta_title': result['meta_title'][:60],
                            'meta_description': result['meta_description'][:160],
                            'is_outdated': False  # сбрасываем флаг устаревания
                        }
                    )
                    
                    # Сохраняем ключевые слова в отдельное поле или модель
                    if result['keywords']:
                        # Здесь можно сохранить keywords в JSONField
                        pass
                    
                    status = 'создан' if created else 'обновлен'
                    self.stdout.write(f'  Перевод {status}: {translation.title}')
                
                # Пауза, чтобы не превысить RPM (Requests Per Minute) лимиты API
                time.sleep(1)
                
            except Exception as e:
                self.stderr.write(f'  Ошибка: {e}')
                continue
        
        self.stdout.write('Готово!')

Ключевые моменты: пауза в 1 секунду между запросами, обработка через транзакции, ограничение лимита. Запускать так: python manage.py translate_articles --lang=en --limit=10

4 Заставляем систему следить за обновлениями

Сигналы Django - ваш друг. Добавьте в apps.py или в отдельный файл signals.py:

from django.db.models.signals import post_save
from django.dispatch import receiver
from blog.models import Article, ArticleTranslation

@receiver(post_save, sender=Article)
def mark_translations_outdated(sender, instance, **kwargs):
    """При обновлении статьи помечаем все переводы как устаревшие."""
    if kwargs.get('update_fields') is not None:  # только при обновлении
        ArticleTranslation.objects.filter(article=instance).update(is_outdated=True)
        print(f"Переводы статьи '{instance.title}' помечены как устаревшие")

Теперь при правке оригинала система автоматически отметит переводы для обновления. Запустите скрипт с флагом --only-outdated, чтобы обновить только измененные статьи.

5 Автоматизируем запуск: Cron vs Celery

Для простоты используйте Cron. Добавьте в crontab:

# Каждый день в 3 ночи переводим новые статьи
0 3 * * * cd /path/to/your/project && /usr/bin/python3 manage.py translate_articles --lang=en --limit=5

# Каждое воскресенье обновляем устаревшие переводы
0 4 * * 0 cd /path/to/your/project && /usr/bin/python3 manage.py translate_articles --lang=en --only-outdated --limit=20

Если у вас высоконагруженный блог, используйте Celery с очередями. Но для 99% случаев Cron хватает.

Подводные камни, которые вас ждут

Вопросы, которые вы зададите через неделю

А если ChatGPT заблокирован в моей стране?

Используйте официальный прокси или автоматическое обновление DNS-правил. Альтернатива - локальные модели вроде Qwen2.5, но качество перевода будет хуже.

Можно ли переводить на 5 языков сразу?

Можно, но стоимость вырастет линейно. И учтите, что для некоторых языков (например, японского) лучше использовать специфичные промпты.

Как быть с изображениями и alt-текстами?

Добавьте в промпт: "Переведи также alt-тексты для изображений в формате [image: описание изображения]". Парсите их отдельно. Это тема для отдельного гайда.

Что в итоге

Вы тратите 4 часа на настройку системы, которая потом экономит вам 10 часов в месяц. Переводы становятся консистентными, мета-теги - SEO-дружелюбными, а читатели из других стран - лояльными.

Самое сложное - не написать код, а правильно настроить промпты. Потратьте день на эксперименты: как ChatGPT переводит ваши самые сложные статьи. Добавьте в system prompt особенности вашего блога.

И помните: даже самый продвинутый ИИ не заменит human touch. Раз в месяц просматривайте переводы, особенно первые несколько. Ваш личный AI-фильтр все равно нужен.

Код из статьи - рабочий. Берите, копируйте, адаптируйте под свой блог. Если сломаете что-то в продакшене - виноваты только вы. Но если заработает - напишите мне, какую кучу времени сэкономили.

Подписаться на канал