Babel Fish AI، مشروع شخصي، هي إضافة كروم مبتكرة تحول الصوت إلى نص بدقة استثنائية، مع تقديم خيار للترجمة التلقائية. صممت لتكون موثوقة وخالية من الإعلانات، وتوفر تحويل صوتي عالي الجودة عبر واجهة API الخاصة بـ Whisper من OpenAI. لقد أنشأت هذه الإضافة جزئيًا لتلبية حاجة شخصية: تبسيط التواصل مع الذكاء الاصطناعي عن طريق إملاء طلباتي. يمكنك استخدامها حصريًا للتحويل الصوتي أو تفعيل الترجمة لتسهيل التواصل متعدد اللغات. كما كانت فرصة مثالية لاختبار Roo Code، أداة تطوير مدعومة بالذكاء الاصطناعي.

Babel Fish AI, projekt osobisty, to nowatorskie rozszerzenie Chrome, które przekształca mowę na tekst z wyjątkową precyzją, oferując jednocześnie możliwość automatycznego tłumaczenia. Zaprojektowane tak, aby było niezawodne i wolne od reklam, zapewnia wysokiej jakości transkrypcję głosową dzięki API Whisper firmy OpenAI. Stworzyłem to rozszerzenie częściowo, aby odpowiedzieć na osobistą potrzebę: uproszczenie komunikacji z AI poprzez dyktowanie moich zapytań. Możesz korzystać z niego wyłącznie do transkrypcji lub aktywować tłumaczenie, aby ułatwić komunikację wielojęzyczną. Była to również idealna okazja do przetestowania Roo Code, narzędzia wspomaganego przez AI.

Babel Fish AI, ein persönliches Projekt, ist eine innovative Chrome-Erweiterung, die Sprache mit außergewöhnlicher Präzision in Text umwandelt und gleichzeitig eine automatische Übersetzungsoption bietet. Entwickelt, um zuverlässig und werbefrei zu sein, liefert sie eine hochwertige Spracherkennung über die Whisper-API von OpenAI. Ich habe diese Erweiterung zum Teil entwickelt, um einen persönlichen Bedarf zu decken: die Kommunikation mit KIs zu vereinfachen, indem ich meine Anfragen diktiere. Sie können sie ausschließlich für die Transkription verwenden oder die Übersetzung aktivieren, um die mehrsprachige Kommunikation zu erleichtern. Es war auch die ideale Gelegenheit, Roo Code zu testen, ein KI-gestütztes Entwicklungswerkzeug.

Babel Fish AI, a personal project, is an innovative Chrome extension that transforms voice into text with exceptional accuracy while offering an automatic translation option. Designed to be reliable and ad-free, it provides quality voice transcription via OpenAI’s Whisper API. I created this extension partly to fulfill a personal need: to simplify communication with AIs by dictating my requests.
You can use it exclusively for transcription or activate translation to facilitate multilingual communication.
It was also the perfect opportunity to test Roo Code, an AI-assisted development tool.

Babel Fish AI, un proyecto personal, es una extensión Chrome innovadora que transforma la voz en texto con una precisión excepcional, a la vez que ofrece una opción de traducción automática. Diseñada para ser fiable y sin publicidad, proporciona una transcripción vocal de calidad a través de la API Whisper de OpenAI. Creé esta extensión en parte para responder a una necesidad personal: simplificar la comunicación con las IA dictando mis solicitudes. Puedes utilizarla exclusivamente para la transcripción o activar la traducción para facilitar la comunicación multilingüe. También fue la ocasión ideal para probar Roo Code, una herramienta de desarrollo asistida por IA.

Babel Fish AI, ett personligt projekt, är ett innovativt Chrome-tillägg som omvandlar röst till text med exceptionell precision, samtidigt som det erbjuder ett alternativ för automatisk översättning. Utformat för att vara pålitligt och reklamfritt, levererar det en rösttranskription av hög kvalitet via OpenAIs Whisper API. Jag skapade detta tillägg delvis för att tillgodose ett personligt behov: att förenkla kommunikationen med AI genom att diktera mina förfrågningar. Du kan använda det enbart för transkription eller aktivera översättningen för att underlätta flerspråkig kommunikation. Det var också ett perfekt tillfälle att testa Roo Code, ett AI-assisterat utvecklingsverktyg.

Babel Fish AI, un proiect personal, este o extensie Chrome inovatoare care transformă vocea în text cu o precizie excepțională, oferind totodată o opțiune de traducere automată. Proiectată pentru a fi fiabilă și fără reclame, ea furnizează o transcriere vocală de calitate prin API-ul Whisper de la OpenAI. Am creat această extensie, parțial în scopul de a răspunde unei nevoi personale: simplificarea comunicării cu IA prin dictarea solicitărilor mele. Puteți să o folosiți exclusiv pentru transcriere sau să activați traducerea pentru a facilita comunicarea multilingvă. A fost, de asemenea, ocazia ideală pentru a testa Roo Code, un instrument de dezvoltare asistată de IA.

Babel Fish AI, un progetto personale, è un’estensione Chrome innovativa che trasforma la voce in testo con una precisione eccezionale, offrendo al contempo un’opzione di traduzione automatica. Progettata per essere affidabile e senza pubblicità, fornisce una trascrizione vocale di qualità tramite l’API Whisper di OpenAI. Ho creato questa estensione in parte per rispondere a un’esigenza personale: semplificare la comunicazione con le IA dettando le mie richieste. Puoi usarla esclusivamente per la trascrizione o attivare la traduzione per facilitare la comunicazione multilingue. Era anche l’occasione ideale per testare Roo Code, uno strumento di sviluppo assistito da IA.

Babel Fish AI, een persoonlijk project, is een innovatieve Chrome-extensie die spraak omzet in tekst met een uitzonderlijke nauwkeurigheid, terwijl het een optie voor automatische vertaling biedt. Ontworpen om betrouwbaar en reclamevrij te zijn, levert het een kwalitatieve spraaktranscriptie via de Whisper API van OpenAI. Ik heb deze extensie onder andere ontwikkeld om in een persoonlijke behoefte te voorzien: het vereenvoudigen van de communicatie met AI door mijn commando’s in te spreken.
Je kunt het uitsluitend gebruiken voor transcriptie of de vertaling activeren om meertalige communicatie te vergemakkelijken.
Het was ook de ideale gelegenheid om Roo Code te testen, een AI-ondersteund ontwikkelingshulpmiddel.

Babel Fish AI, un projet personnel, est une extension Chrome innovante qui transforme la voix en texte avec une précision exceptionnelle, tout en offrant une option de traduction automatique. Conçue pour être fiable et sans publicité, elle fournit une transcription vocale de qualité via l’API Whisper d’OpenAI. J’ai créé cette extension en partie pour répondre à un besoin personnel : simplifier la communication avec les IA en dictant mes requêtes. Vous pouvez l’utiliser exclusivement pour la transcription ou activer la traduction pour faciliter la communication multi-langue. C’était aussi l’occasion idéale de tester Roo Code, un outil de développement assisté par IA.

Babel Fish AI, um projeto pessoal, é uma extensão Chrome inovadora que transforma a voz em texto com uma precisão excepcional, além de oferecer uma opção de tradução automática. Projetada para ser confiável e sem publicidade, ela fornece uma transcrição vocal de qualidade através da API Whisper da OpenAI. Criei essa extensão em parte para atender a uma necessidade pessoal: simplificar a comunicação com as IAs ditando minhas solicitações.
Você pode usá-la exclusivamente para a transcrição ou ativar a tradução para facilitar a comunicação multilíngue.
Também foi a ocasião ideal para testar Roo Code, uma ferramenta de desenvolvimento assistida por IA.

Babel Fish AIは個人的なプロジェクトであり、極めて正確に音声をテキストに変換するChrome拡張機能で、同時に自動翻訳オプションも提供します。信頼性が高く広告がなく、OpenAIのWhisper APIを通じて質の高い音声認識を実現します。この拡張機能は、私自身の必要性に応えて、音声で要求を入力することでAIとのコミュニケーションを簡素化するために一部作成されました。 音声認識専用で利用することも、翻訳機能を有効にして多言語コミュニケーションを促進することも可能です。 また、Roo Codeという、AI支援開発ツールのテストの絶好の機会でもありました。

Babel Fish AI 是一个个人项目，是一款创新的 Chrome 扩展，能够以非凡的精度将语音转换为文本，同时还提供自动翻译选项。它的设计旨在保证可靠且无广告，通过 OpenAI 的 Whisper API 提供高质量的语音转录。我创建此扩展部分是为了满足个人需求：通过口述指令简化与人工智能的沟通。 您可以仅使用它进行转录，或者激活翻译功能以促进多语言交流。 这也是测试 Roo Code —— 一款由 AI 辅助开发的工具 —— 的绝佳时机。

Babel Fish AI는 개인 프로젝트로, 탁월한 정확도로 음성을 텍스트로 변환하면서 자동 번역 옵션을 제공하는 혁신적인 Chrome 확장 프로그램입니다. 광고 없이 신뢰할 수 있도록 설계되었으며, OpenAI의 Whisper API를 통해 고품질 음성 전사를 제공합니다. 저는 AI와 대화할 때 명령을 받아들이기 위해 음성으로 요청을 간소화하는 개인적인 필요를 충족하기 위해 이 확장을 제작했습니다. 전사 전용으로 사용하거나 다국어 통신을 쉽게 하기 위해 번역을 활성화할 수 있습니다. 또한 Roo Code를 테스트할 수 있는 이상적인 기회이기도 했습니다.

Babel Fish AI, एक व्यक्तिगत प्रोजेक्ट, एक अभिनव Chrome एक्सटेंशन है जो अत्यधिक सटीकता के साथ आवाज को टेक्स्ट में बदलता है, साथ ही एक स्वत: अनुवाद विकल्प भी प्रदान करता है। इसे विश्वसनीय और विज्ञापन मुक्त बनाने के लिए डिज़ाइन किया गया है, और यह OpenAI के Whisper API के माध्यम से गुणवत्तापूर्ण आवाज ट्रांसक्रिप्शन प्रदान करता है। मैंने इस एक्सटेंशन को आंशिक रूप से एक व्यक्तिगत आवश्यकता के जवाब में बनाया ताकि आईए के साथ संवाद करना सरल हो सके, अपनी क्वेरी को डिक्टेट करके।
आप इसे केवल ट्रांसक्रिप्शन के लिए उपयोग कर सकते हैं या बहुभाषी संचार को सरल बनाने के लिए अनुवाद को सक्रिय कर सकते हैं।
यह Roo Code का परीक्षण करने का भी एक आदर्श अवसर था, जो एक AI-सहायता प्राप्त विकास उपकरण है।

我很高兴地宣布，我的博客增添了八种新语言以便于对文章进行自动翻译！新语言包括：

• 意大利语：Tradotto da IA in Italiano
• 德语：KI-Übersetzung auf Deutsch
• 瑞典语：AI-översatt svenska
• 波兰语：Tłumaczenie AI na język polski
• 荷兰语：AI-vertaald Nederlands
• 罗马尼亚语：Tradus de IA în Română
• 日语：AI翻訳日本語
• 韩语：AI 번역 한국어

私のブログがさらに多くの言語に対応して、世界中の読者に届けられるようになったことをお知らせできることを大変嬉しく思います！この度、自動翻訳に対応した8つの新しい言語が追加されました。新たに利用可能な言語は以下の通りです：

• イタリア語： Tradotto da IA in Italiano
• ドイツ語： KI-Übersetzung auf Deutsch
• スウェーデン語： AI-översatt svenska
• ポーランド語： Tłumaczenie AI na język polski
• オランダ語： AI-vertaald Nederlands
• ルーマニア語： Tradus de IA în Română
• 日本語： AI翻訳日本語
• 韓国語： AI 번역 한국어

मुझे यह घोषणा करते हुए खुशी हो रही है कि मेरे ब्लॉग ने मेरे लेखों के स्वचालित अनुवाद के लिए आठ नई भाषाओं को जोड़ते हुए दुनिया भर में और अधिक खोल दिया है! उपलब्ध नई भाषाएँ हैं:

• इतालवी : Tradotto da IA in Italiano
• जर्मन : KI-Übersetzung auf Deutsch
• स्वीडिश : AI-översatt svenska
• पोलिश : Tłumaczenie AI na język polski
• डच : AI-vertaald Nederlands
• रोमानियाई : Tradus de IA în Română
• जापानी : AI翻訳日本語
• कोरियाई : AI 번역 한국어

يسعدني أن أعلن أن مدونتي أصبحت تنفتح أكثر على العالم مع إضافة ثمان لغات جديدة لترجمات المقالات التلقائية! اللغات الجديدة المتاحة هي:

• الإيطالية: Tradotto da IA in Italiano
• الألمانية: KI-Übersetzung auf Deutsch
• السويدية: AI-översatt svenska
• البولندية: Tłumaczenie AI na język polski
• الهولندية: AI-vertaald Nederlands
• الرومانية: Tradus de IA în Română
• اليابانية: AI翻訳日本語
• الكورية: AI 번역 한국어

Ik ben verheugd u aan te kondigen dat mijn blog zich nog meer opent voor de wereld met de toevoeging van acht nieuwe talen voor automatische vertalingen van mijn artikelen! De nieuwe beschikbare talen zijn:

• Italiaans: Tradotto da IA in Italiano
• Duits: KI-Übersetzung auf Deutsch
• Zweeds: AI-översatt svenska
• Pools: Tłumaczenie AI na język polski
• Nederlands: AI-vertaald Nederlands
• Roemeens: Tradus de IA în Română
• Japans: AI翻訳日本語
• Koreaans: AI 번역 한국어

Ich freue mich, Ihnen mitteilen zu können, dass mein Blog noch mehr globale Reichweite erlangt hat, indem acht neue Sprachen für automatische Übersetzungen meiner Artikel hinzugefügt wurden! Die neuen verfügbaren Sprachen sind:

• Italienisch: Tradotto da IA in Italiano
• Deutsch: KI-Übersetzung auf Deutsch
• Schwedisch: AI-översatt svenska
• Polnisch: Tłumaczenie AI na język polski
• Niederländisch: AI-vertaald Nederlands
• Rumänisch: Tradus de IA în Română
• Japanisch: AI翻訳日本語
• Koreanisch: AI 번역 한국어

Estou feliz em anunciar que meu blog está se abrindo ainda mais para o mundo com a adição de oito novos idiomas para traduções automáticas dos meus artigos! Os novos idiomas disponíveis são:

• Italiano: Tradotto da IA in Italiano
• Alemão: KI-Übersetzung auf Deutsch
• Sueco: AI-översatt svenska
• Polonês: Tłumaczenie AI na język polski
• Holandês: AI-vertaald Nederlands
• Romeno: Tradus de IA în Română
• Japonês: AI翻訳日本語
• Coreano: AI 번역 한국어

Z radością ogłaszam, że mój blog otwiera się jeszcze bardziej na świat, dodając osiem nowych języków do automatycznych tłumaczeń moich artykułów! Nowe dostępne języki to:

• Włoski: Tradotto da IA in Italiano
• Niemiecki: KI-Übersetzung auf Deutsch
• Szwedzki: AI-översatt svenska
• Polski: Tłumaczenie AI na język polski
• Niderlandzki: AI-vertaald Nederlands
• Rumuński: Tradus de IA în Română
• Japoński: AI翻訳日本語
• Koreański: AI 번역 한국어

Sunt încântat să vă anunț că blogul meu se deschide și mai mult spre lume cu adăugarea a opt noi limbi pentru traducerile automate ale articolelor mele! Limbile noi disponibile sunt:

• Italiană : Tradotto da IA in Italiano
• Germană : KI-Übersetzung auf Deutsch
• Suedeză : AI-översatt svenska
• Poloneză : Tłumaczenie AI na język polski
• Neerlandeză : AI-vertaald Nederlands
• Română : Tradus de IA în Română
• Japoneză : AI翻訳日本語
• Coreeană : AI 번역 한국어

내 블로그가 기사 자동 번역을 위한 여덟 개의 새로운 언어 추가와 함께 더 많은 세계로 열리게 되어 기쁩니다! 사용할 수 있는 새로운 언어는 다음과 같습니다:

• 이탈리아어 : Tradotto da IA in Italiano
• 독일어 : KI-Übersetzung auf Deutsch
• 스웨덴어 : AI-översatt svenska
• 폴란드어 : Tłumaczenie AI na język polski
• 네덜란드어 : AI-vertaald Nederlands
• 루마니아어 : Tradus de IA în Română
• 일본어 : AI翻訳日本語
• 한국어 : AI 번역 한국어

I am delighted to announce that my blog is opening up even more to the world with the addition of eight new languages for automatic translations of my articles! The new available languages are:

• Italian: Tradotto da IA in Italiano
• German: KI-Übersetzung auf Deutsch
• Swedish: AI-översatt svenska
• Polish: Tłumaczenie AI na język polski
• Dutch: AI-vertaald Nederlands
• Romanian: Tradus de IA în Română
• Japanese: AI翻訳日本語
• Korean: AI 번역 한국어

Je suis ravi de vous annoncer que mon blog s’ouvre encore plus au monde avec l’ajout de huit nouvelles langues pour les traductions automatiques de mes articles ! Les nouvelles langues disponibles sont :

• Italien : Tradotto da IA in Italiano
• Allemand : KI-Übersetzung auf Deutsch
• Suédois : AI-översatt svenska
• Polonais : Tłumaczenie AI na język polski
• Néerlandais : AI-vertaald Nederlands
• Roumain : Tradus de IA în Română
• Japonais : AI翻訳日本語
• Coréen : AI 번역 한국어

Jag är glad att kunna meddela att min blogg öppnar sig ännu mer för världen genom att lägga till åtta nya språk för automatiska översättningar av mina artiklar! De nya tillgängliga språken är:

• Italienska : Tradotto da IA in Italiano
• Tyska : KI-Übersetzung auf Deutsch
• Svenska : AI-översatt svenska
• Polska : Tłumaczenie AI na język polski
• Holländska : AI-vertaald Nederlands
• Rumänska : Tradus de IA în Română
• Japanska : AI翻訳日本語
• Koreanska : AI 번역 한국어

Sono lieto di annunciare che il mio blog si apre ancora di più al mondo con l’aggiunta di otto nuove lingue per le traduzioni automatiche dei miei articoli! Le nuove lingue disponibili sono:

• Italiano : Tradotto da IA in Italiano
• Tedesco : KI-Übersetzung auf Deutsch
• Svedese : AI-översatt svenska
• Polacco : Tłumaczenie AI na język polski
• Olandese : AI-vertaald Nederlands
• Rumeno : Tradus de IA în Română
• Giapponese : AI翻訳日本語
• Coreano : AI 번역 한국어

Me complace anunciar que mi blog se abre aún más al mundo con la adición de ocho nuevos idiomas para las traducciones automáticas de mis artículos! Los nuevos idiomas disponibles son:

• Italiano: Tradotto da IA in Italiano
• Alemán: KI-Übersetzung auf Deutsch
• Sueco: AI-översatt svenska
• Polaco: Tłumaczenie AI na język polski
• Neerlandés: AI-vertaald Nederlands
• Rumano: Tradus de IA în Română
• Japonés: AI翻訳日本語
• Coreano: AI 번역 한국어

通过 StoryPixAI，我的目标是创建一个交互式网页应用，允许用户生成儿童故事，并由人工智能模型生成的图片进行丰富。为了实现这一目标，我使用了多个AWS服务，如Lambda、API Gateway、DynamoDB、S3和Cognito来进行认证。基础设施代码由Terraform管理，部署通过GitLab CI自动化。在这篇文章中，我将揭示这个令人兴奋的项目背后的故事，包括技术选择和遇到的挑战。

StoryPixAIの目標は、ユーザーが生成AIモデルによって生成された画像で強化された子供のための物語を生成することを可能にするインタラクティブなWebアプリケーションを作成することでした。これを実現するために、Lambda、API Gateway、DynamoDB、S3、および認証のためにCognitoといった複数のAWSサービスを使用しました。インフラストラクチャのコードはTerraformで管理され、デプロイはGitLab CI経由で自動化されています。このブログ記事では、このエキサイティングなプロジェクトの裏側、技術的選択、および直面した課題について紹介します。

StoryPixAI के साथ मेरा उद्देश्य एक इंटरैक्टिव वेब एप्लिकेशन बनाना था जो उपयोगकर्ताओं को बच्चों के लिए कहानियाँ बनाने की अनुमति देता है, जिनमें AI मॉडल्स द्वारा उत्पन्न चित्र होते हैं। इसे पूरा करने के लिए, मैंने AWS की कई सेवाओं का उपयोग किया जैसे Lambda, API Gateway, DynamoDB, S3 और संज्ञानात्मक प्रमाणीकरण के लिए Cognito। इंफ्रास्ट्रक्चर कोड को Terraform के साथ प्रबंधित किया गया है, और तैनाती को GitLab CI के माध्यम से स्वचालित किया गया है। इस ब्लॉग पोस्ट में, मैं इस रोमांचक परियोजना के पीछे की तकनीकी चुनावों और सामने आई चुनौतियों की झलक प्रस्तुत करता हूँ।

مع StoryPixAI كان هدفي هو إنشاء تطبيق ويب تفاعلي يسمح للمستخدمين بإنشاء قصص للأطفال، والتي تُثري بالصور المولدة بواسطة نماذج الذكاء الاصطناعي. لتحقيق ذلك، استخدمت عدة خدمات من AWS مثل Lambda، API Gateway، DynamoDB، S3 وCognito للمصادقة. كود البنية التحتية يُدار باستخدام Terraform، والنشر مؤتمت عبر GitLab CI. في هذا المقال، سأكشف لكم كواليس هذا المشروع المثير، من الخيارات التكنولوجية إلى التحديات التي واجهتها.

Met StoryPixAI was mijn doel om een interactieve webapplicatie te creëren waarmee gebruikers verhalen voor kinderen kunnen genereren, verrijkt met afbeeldingen die zijn gegenereerd door kunstmatige intelligentiemodellen. Hiervoor heb ik verschillende AWS-services gebruikt, zoals Lambda, API Gateway, DynamoDB, S3 en Cognito voor authenticatie. De infrastructuurcode wordt beheerd met Terraform en de deployment is geautomatiseerd via GitLab CI. In dit artikel onthul ik de geheimen van dit spannende project, van technologische keuzes tot de uitdagingen die ik ben tegengekomen.

Z StoryPixAI moim celem było stworzenie interaktywnej aplikacji internetowej, która umożliwia użytkownikom generowanie historii dla dzieci, wzbogaconych o obrazy generowane przez modele sztucznej inteligencji. Aby to osiągnąć, użyłem kilku usług AWS, takich jak Lambda, API Gateway, DynamoDB, S3 i Cognito do uwierzytelniania. Kod infrastruktury jest zarządzany za pomocą Terraform, a wdrażanie jest zautomatyzowane za pomocą GitLab CI. W tym wpisie zdradzam kulisy tego ekscytującego projektu, decyzje technologiczne i napotkane wyzwania.

Med StoryPixAI var mitt mål att skapa en interaktiv webbapplikation som gör det möjligt för användare att generera barnhistorier, berikade med bilder skapade av artificiella intelligensmodeller. För att uppnå detta använde jag flera AWS-tjänster som Lambda, API Gateway, DynamoDB, S3 och Cognito för autentisering. Infrastrukturkoden hanteras med Terraform, och distributionen automatiseras via GitLab CI. I detta inlägg avslöjar jag projektets bakomliggande val och de utmaningar som mötts.

Mit StoryPixAI war es mein Ziel, eine interaktive Webanwendung zu erstellen, die es den Nutzern ermöglicht, Kindergeschichten zu generieren, die durch Bilder ergänzt werden, die von Modellen der künstlichen Intelligenz erstellt wurden. Um dies zu realisieren, habe ich mehrere AWS-Dienste wie Lambda, API Gateway, DynamoDB, S3 und Cognito für die Authentifizierung verwendet. Der Infrastrukturcode wird mit Terraform verwaltet und die Bereitstellung ist über GitLab CI automatisiert. In diesem Beitrag enthülle ich die Hintergründe dieses spannenden Projekts, von technologischen Entscheidungen bis hin zu den Herausforderungen, denen ich begegnet bin.

Com StoryPixAI meu objetivo era criar um aplicativo web interativo que permitisse aos usuários gerar histórias para crianças, enriquecidas com imagens geradas por modelos de inteligência artificial. Para realizar isso, utilizei vários serviços AWS, como Lambda, API Gateway, DynamoDB, S3 e Cognito para autenticação. O código da infraestrutura é gerido com Terraform, e a implantação é automatizada via GitLab CI. Neste post, revelo os bastidores deste projeto empolgante, desde as escolhas tecnológicas até os desafios enfrentados.

Avec StoryPixAI mon objectif était de créer une application web interactive permettant aux utilisateurs de générer des histoires pour enfants, enrichies par des images générées par des modèles d’intelligence artificielle. Pour réaliser cela, j’ai utilisé plusieurs services AWS tels que Lambda, API Gateway, DynamoDB, S3 et Cognito pour l’authentification. Le code de l’infrastructure est géré avec Terraform, et le déploiement est automatisé via GitLab CI. Dans ce billet, je vous dévoile les coulisses de ce projet passionnant, des choix technologiques aux défis rencontrés.

With StoryPixAI, my goal was to create an interactive web application allowing users to generate children’s stories, enriched by images generated by artificial intelligence models. To achieve this, I used several AWS services such as Lambda, API Gateway, DynamoDB, S3, and Cognito for authentication. The infrastructure code is managed with Terraform, and the deployment is automated via GitLab CI. In this post, I unveil the behind-the-scenes of this exciting project, from technological choices to challenges encountered.

Cu StoryPixAI, obiectivul meu a fost să creez o aplicație web interactivă care să permită utilizatorilor să genereze povești pentru copii, îmbogățite cu imagini generate de modele de inteligență artificială. Pentru a realiza aceasta, am folosit mai multe servicii AWS precum Lambda, API Gateway, DynamoDB, S3 și Cognito pentru autentificare. Codul infrastructurii este gestionat cu Terraform, iar implementarea este automatizată prin GitLab CI. În acest articol, vă dezvălui culisele acestui proiect palpitant, de la alegerile tehnologice până la provocările întâmpinate.

Con StoryPixAI il mio obiettivo era di creare un’applicazione web interattiva che permettesse agli utenti di generare storie per bambini, arricchite da immagini generate da modelli di intelligenza artificiale. Per realizzare ciò, ho utilizzato diversi servizi AWS come Lambda, API Gateway, DynamoDB, S3 e Cognito per l’autenticazione. Il codice dell’infrastruttura è gestito con Terraform, e il deployment è automatizzato tramite GitLab CI. In questo post, vi svelerò i retroscena di questo progetto appassionante, dalle scelte tecnologiche alle sfide incontrate.

Con StoryPixAI, mi objetivo era crear una aplicación web interactiva que permitiera a los usuarios generar historias para niños, enriquecidas con imágenes generadas por modelos de inteligencia artificial. Para lograrlo, utilicé varios servicios de AWS como Lambda, API Gateway, DynamoDB, S3 y Cognito para la autenticación. El código de la infraestructura se gestiona con Terraform, y el despliegue está automatizado a través de GitLab CI. En esta entrada, les revelo los entresijos de este emocionante proyecto, desde las elecciones tecnológicas hasta los desafíos encontrados.

StoryPixAI를 통해 내 목표는 사용자가 인공지능 모델이 생성한 이미지로 채워진 어린이 이야기를 생성할 수 있게 하는 인터랙티브 웹 애플리케이션을 만드는 것이었습니다. 이를 위해 Lambda, API Gateway, DynamoDB, S3, Cognito와 같은 여러 AWS 서비스를 사용했습니다. 인프라 코드는 Terraform을 통해 관리되고, 배포는 GitLab CI를 통해 자동화됩니다. 이 블로그 글에서는 흥미진진한 이 프로젝트의 후기를 기술 선택에서 겪은 도전 과제까지 공개합니다.

يقدم هذا المقال مشروع POC (دليل إثبات المفهوم) للنشر الآلي لـ LibreChat على AWS EC2، باستخدام Terraform لتنسيق البنية التحتية وفقًا لمبدأ البنية التحتية كرمز، وبرنامج User-Data Bash لتثبيت المكونات على EC2، وAWS Systems Manager لإدارة مركزية لمفاتيح API وتتبع النشر. يتم التركيز على الأتمتة وتحسين التكاليف من خلال استخدام حالات Spot.

Ten artykuł przedstawia projekt POC (Proof of Concept) dla zautomatyzowanego wdrażania LibreChat na AWS EC2, używając Terraform do orkiestracji infrastruktury zgodnie z zasadą Infrastructure as Code, skryptu User-Data Bash do instalacji komponentów na EC2 i AWS Systems Manager do centralnego zarządzania kluczami API i monitorowania wdrożenia. Skupiono się na automatyzacji i optymalizacji kosztów poprzez wykorzystanie instancji Spot.

这篇文章介绍了一个 项目 POC（概念验证），目的是在AWS EC2上自动部署LibreChat，使用Terraform根据Infrastructure as Code的原则来编排基础设施，使用bash编写的User-Data脚本来安装EC2组件，并使用AWS Systems Manager进行API密钥的集中管理和部署跟踪。重点放在通过使用Spot实例来实现自动化和成本优化。

Dit artikel presenteert een project POC (Proof of Concept) voor de geautomatiseerde implementatie van LibreChat op AWS EC2, met behulp van Terraform om de infrastructuur te orkestreren volgens het principe van Infrastructure as Code, een User-Data Bash-script om de componenten op EC2 te installeren en AWS Systems Manager om centraal API-sleutels te beheren en de implementatie te volgen. De nadruk ligt op automatisering en kostenoptimalisatie door gebruik te maken van Spot-instances.

이 기사는 프로젝트 POC (Proof of Concept)을 EC2에서 LibreChat을 Terraform을 사용하여 인프라를 코드로서 오케스트레이션하고, User-Data Bash 스크립트를 사용하여 EC2에 컴포넌트를 설치하며, AWS Systems Manager를 사용하여 중앙 집중적으로 API 키를 관리하고 배포 진행 상황을 추적하는 방법을 소개합니다. 비용 최적화를 위해 Spot 인스턴스 사용에도 중점을 둡니다.

Questo articolo presenta un progetto POC (Proof of Concept) per la distribuzione automatizzata di LibreChat su AWS EC2, utilizzando Terraform per orchestrare l’infrastruttura secondo il principio di Infrastructure as Code, uno script User-Data Bash per installare i componenti su EC2, e AWS Systems Manager per una gestione centralizzata delle chiavi API e il monitoraggio della distribuzione. L’accento è posto sull’automazione e l’ottimizzazione dei costi tramite l’uso delle istanze Spot.

Este artículo presenta un proyecto POC (Proof of Concept) para el despliegue automatizado de LibreChat en AWS EC2, utilizando Terraform para orquestar la infraestructura según el principio de Infraestructura como Código, un script de User-Data en Bash para instalar los componentes en EC2, y AWS Systems Manager para una gestión centralizada de las claves API y el seguimiento del despliegue. El enfoque está en la automatización y la optimización de costos a través del uso de instancias Spot.

Este artigo apresenta um projeto POC (Proof of Concept) para o desdobramento automatizado do LibreChat na AWS EC2, usando Terraform para orquestrar a infraestrutura de acordo com o princípio de Infraestrutura como Código, um script de Bash User-Data para instalar os componentes na EC2, e AWS Systems Manager para gerenciamento centralizado das chaves de API e acompanhamento do desdobramento. A ênfase está na automação e otimização de custos através do uso de instâncias Spot.

Cet article présente un projet POC (Proof of Concept) pour le déploiement automatisé de LibreChat sur AWS EC2, utilisant Terraform pour orchestrer l’infrastructure selon le principe d’Infrastructure as Code, un script User-Data Bash pour installer les composants sur EC2, et AWS Systems Manager pour une gestion centralisée des clés API et le suivi du déploiement. L’accent est mis sur l’automatisation et l’optimisation des coûts via l’utilisation des instances Spot.

Acest articol prezintă un proiect POC (Proof of Concept) pentru deplasarea automatizată a LibreChat pe AWS EC2, utilizând Terraform pentru orchestrarea infrastructurii conform principiului Infrastructure as Code, un script User-Data Bash pentru a instala componentele pe EC2, și AWS Systems Manager pentru o gestionare centralizată a cheilor API și urmărirea desfășurării. Se pune accent pe automatizare și optimizarea costurilor prin utilizarea instanțelor Spot.

この記事は、インフラストラクチャをコードとして定義するTerraformを利用し、EC2上にLibreChatを自動デプロイするためのPOCプロジェクトを紹介します。EC2にコンポーネントをインストールするためのBashスクリプトUser-Dataを使用し、APIキーの集中管理およびデプロイの追跡にはAWS Systems Managerを使用しています。スポットインスタンスの使用を通じて、自動化とコストの最適化に重点を置いています。

Denna artikel presenterar ett projekt POC (Proof of Concept) för den automatiserade distributionen av LibreChat på AWS EC2, med Terraform för att orkestrera infrastrukturen enligt principen Infrastructure as Code, ett User-Data Bash-skript för att installera komponenter på EC2, och AWS Systems Manager för centraliserad hantering av API-nycklar och uppföljning av distributionen. Fokus ligger på automatisering och kostnadsoptimering genom användning av Spot-instanser.

Dieser Artikel stellt ein POC-Projekt (Proof of Concept) für die automatische Bereitstellung von LibreChat auf AWS EC2 vor, das Terraform zur Orchestrierung der Infrastruktur nach dem Prinzip Infrastructure as Code, ein User-Data-Bash-Skript zur Installation der Komponenten auf EC2 und AWS Systems Manager zur zentralen Verwaltung von API-Schlüsseln und zur Überwachung der Bereitstellung verwendet. Der Schwerpunkt liegt auf der Automatisierung und Kostenoptimierung durch die Nutzung von Spot-Instanzen.

This article presents a POC (Proof of Concept) project for the automated deployment of LibreChat on AWS EC2, using Terraform to orchestrate the infrastructure according to the Infrastructure as Code principle, a Bash User-Data script to install components on EC2, and AWS Systems Manager for centralized API key management and deployment tracking. The focus is on automation and cost optimization through the use of Spot instances.

在使用我的 AI 驱动的 Markdown 翻译脚本(使用 Mistral AI 和 Open AI)翻译我的 GitLab 上的 Stable Diffusion 项目的 README 时,我遇到了一个主要问题。某些部分的文本没有被翻译,某些代码块被错误地翻译。本文介绍了为解决这一关键问题而进行的改进。

在使用我的由AI驱动的Markdown翻译脚本（Mistral AI 和 Open AI）翻译我在 GitLab上的Stable Diffusion项目的README时，我遇到了一个重大问题。有些文本部分没有被翻译，而且某些代码块被错误翻译。本文介绍了为解决这一关键问题所做的改进。

मेरे AI (Mistral AI और Open AI) संचालित Markdown अनुवाद स्क्रिप्ट का उपयोग करते हुए मेरे परियोजना के README GitLab पर स्थिर प्रसार के लिए, मुझे एक प्रमुख समस्या का सामना करना पड़ा। कुछ हिस्से अनुवादित नहीं हुए और कुछ कोड ब्लॉक गलत तरीके से अनुवादित हुए। यह लेख इस समस्या को हल करने के लिए किए गए सुधार को प्रस्तुत करता है।

أثناء استخدامي لسكربت الترجمة الخاص بي بعلامة تنسيق Markdown المعتمد على الذكاء الاصطناعي (Mistral AI و Open AI) من أجل ملف README لمشروعي Stable Diffusion على GitLab، واجهت مشكلة كبيرة. لم تتم ترجمة بعض أجزاء النص وتمت ترجمة بعض كتل الكود بشكل غير صحيح. يعرض هذا المقال التحسين الذي تم إدخاله لحل هذه المشكلة الحرجة.

Bij het gebruik van mijn door AI aangedreven Markdown-vertalingscript (Mistral AI en Open AI) voor de README van mijn project Stable Diffusion op GitLab, stuitte ik op een groot probleem. Sommige delen van de tekst werden niet vertaald en sommige codeblokken werden onjuist vertaald. Dit artikel beschrijft de verbetering die is aangebracht om dit kritieke probleem op te lossen.

Durch die Nutzung meines AI-unterstützten Markdown-Übersetzungsskripts (Mistral AI und Open AI) für das README meines Projekts Stable Diffusion auf GitLab, bin ich auf ein großes Problem gestoßen. Einige Teile des Textes wurden nicht übersetzt und einige Codeblöcke wurden falsch übersetzt. Dieser Artikel stellt die Verbesserung vor, die vorgenommen wurde, um dieses kritische Problem zu lösen.

Korzystając z mojego skryptu do tłumaczenia Markdown zasilanego przez SI (Mistral AI i Open AI) do README mojego projektu Stable Diffusion na GitLab, napotkałem poważny problem. Niektóre części tekstu nie były tłumaczone i niektóre bloki kodu były błędnie tłumaczone. Ten artykuł przedstawia ulepszenie wprowadzone w celu rozwiązania tego krytycznego problemu.

Utilizzando il mio script di traduzione Markdown alimentato dall’IA (Mistral AI e Open AI) per il README del mio progetto Stable Diffusion su GitLab, ho incontrato un problema importante. Alcune parti del testo non venivano tradotte e alcuni blocchi di codice erano tradotti in modo errato. Questo articolo presenta il miglioramento apportato per risolvere questo problema critico.

Utilizando meu script de tradução Markdown alimentado por IA (Mistral AI e Open AI) para o README do meu projeto Stable Diffusion no GitLab, encontrei um problema importante. Algumas partes do texto não eram traduzidas e alguns blocos de código eram traduzidos incorretamente. Este artigo apresenta a melhoria feita para resolver esse problema crítico.

Al utilizar mi script de traducción Markdown alimentado por IA (Mistral AI y Open AI) para el README de mi proyecto Stable Diffusion en GitLab, me encontré con un problema importante. Algunas partes del texto no se tradujeron y algunos bloques de código se tradujeron incorrectamente. Este artículo presenta la mejora realizada para resolver este problema crítico.

While using my AI-powered Markdown translation script (Mistral AI and Open AI) for the README of my Stable Diffusion on GitLab project, I encountered a major issue. Some parts of the text were not translated and some code blocks were incorrectly translated. This article presents the improvement made to solve this critical problem.

While using my AI-powered Markdown translation script (Mistral AI and Open AI) for the README of my project Stable Diffusion on GitLab, I encountered a major problem. Some parts of the text were not translated and some code blocks were incorrectly translated. This article presents the improvement made to resolve this critical issue.

Folosind scriptul meu de traducere Markdown alimentat de AI (Mistral AI și Open AI) pentru README-ul proiectului meu Stable Diffusion pe GitLab, am întâmpinat o problemă majoră. Unele părți ale textului nu erau traduse și unele blocuri de cod erau traduse incorect. Acest articol prezintă îmbunătățirea adusă pentru a rezolva această problemă critică.

Vid användning av mitt AI-drivna Markdown-översättningsskript (Mistral AI och Open AI) för README-filen i mitt projekt Stable Diffusion på GitLab, stötte jag på ett stort problem. Vissa delar av texten översattes inte och en del kodblock översattes felaktigt. Denna artikel presenterar förbättringen som gjorts för att lösa detta kritiska problem.

En utilisant mon script de traduction Markdown alimenté par l’IA (Mistral AI et Open AI) pour le README de mon projet Stable Diffusion sur GitLab, j’ai rencontré un problème majeur. Certaines parties du texte n’étaient pas traduites et certains blocs de code étaient incorrectement traduits. Cet article présente l’amélioration apportée pour résoudre ce problème critique.

私のプロジェクト「GitLab上のStable Diffusion」のREADMEをAI（Mistral AIとOpen AI）で翻訳するMarkdownスクリプトを使用している際に、大きな問題に直面しました。テキストの一部が翻訳されず、コードブロックが誤って翻訳されることがありました。この記事では、この重大な問題を解決するために行った改善点について紹介します。

Mistral AI와 Open AI로 구동되는 내 Markdown 번역 스크립트를 사용하여 GitLab의 Stable Diffusion 프로젝트 README를 번역하는 동안 큰 문제에 직면했다. 텍스트의 일부가 번역되지 않았고 일부 코드 블록이 잘못 번역되었다. 이 글에서는 이 중요한 문제를 해결하기 위한 개선점을 소개한다.

在这篇文章中，我将向您介绍我使用人工智能进行博客翻译的脚本的演进，以及整合 Mistral AI 技术的过程。要查看所有语言的结果，我邀请您访问这个页面：使用 Mistral AI 的翻译。

在这篇文章中,我将与您分享我的博客翻译脚本的演变,该脚本使用人工智能,并集成了Mistral AI技术。要查看所有语言的结果,请访问此页面:Mistral AI翻译。

在本文中，我将与您分享使用人工智能的博客翻译脚本的演进，并整合了 Mistral AI 技术。要在所有语言中查看结果，请访问此页面：使用 Mistral AI 进行翻译。

为什么要这个脚本？

我的翻译脚本的目标是使我的博客文章能够在多种语言中获得，通过自动化其翻译。想象一下一个智能翻译器，能够阅读法语文章并忠实地将其还原为英语、西班牙语或其他语言，同时保留原始格式。这就是我的脚本所做的，它利用了最新的人工智能进步。

初始脚本的主要功能

1. 自动翻译：使用 OpenAI 或 Mistral AI API 进行精确翻译。
2. 保留格式：脚本保留了原始格式，包括代码块和链接。
3. 多语言：能够翻译成多种语言。
4. 支持 Markdown：适用于常用于博客中的 Markdown 文件。
5. 自动化：通过单个命令翻译多篇文章。

整合 Mistral AI 的新功能

Mistral AI 整合

Mistral AI 是一个提供自然语言处理服务的先进人工智能平台。通过整合 Mistral AI，我可以扩大我的脚本的翻译和自动化能力，充分利用另一个强大的人工智能资源。此外，Mistral AI 是一家法国公司！

智能文本分段

脚本现在可以将长文本分段，以便更好地适应 AI 模型的令牌限制，从而更有效地管理大量文本的翻译。

添加翻译说明

新功能可以在翻译后的文档末尾添加翻译说明，告知读者翻译过程。

选择 OpenAI 和 Mistral AI

脚本现在提供了选择 OpenAI 和 Mistral AI 进行翻译的灵活性，根据用户的具体需求和首选项。

文件和目录管理

改进了文件和目录的管理，允许在必要时排除某些部分的翻译过程。

脚本代码

更新后的脚本可以在 我的 GitLab 上查找。

您还可以在此处找到它的当前版本：

#!/usr/bin/env python3

import os
import argparse
import time
from openai import OpenAI
import re
from mistralai.client import MistralClient
from mistralai.models.chat_completion import ChatMessage

EXCLUDE_PATTERNS = ["traductions_"]

# Initialisation de la configuration avec les valeurs par défaut
DEFAULT_OPENAI_API_KEY = "votre-clé-api-openai-par-défaut"
DEFAULT_MISTRAL_API_KEY = "votre-clé-api-mistral-par-défaut"
DEFAULT_MODEL_OPENAI = "gpt-4-1106-preview"
DEFAULT_MODEL_MISTRAL = "mistral-medium"
DEFAULT_SOURCE_LANG = "fr"
DEFAULT_TARGET_LANG = "en"
DEFAULT_SOURCE_DIR = "content/posts"
DEFAULT_TARGET_DIR = "traductions_en"
MODEL_TOKEN_LIMITS = {
    "gpt-4-1106-preview": 4096,
    "gpt-4-vision-preview": 4096,
    "gpt-4": 8192,
    "gpt-4-32k": 32768,
    "gpt-4-0613": 8192,
    "gpt-4-32k-0613": 32768,
}


def segment_text(text, max_length):
    """
    Divise un texte Markdown en segments ne dépassant pas la longueur maximale spécifiée,
    en essayant de conserver des points de coupure naturels.

    Args:
        text (str): Texte Markdown à diviser.
        max_length (int): Longueur maximale de chaque segment.

    Returns:
        list[str]: Liste des segments de texte Markdown.
    """
    segments = []
    while text:
        if len(text) <= max_length:
            segments.append(text)
            break
        segment = text[:max_length]
        next_index = max_length

        # Recherche de points de coupure naturels (fin de phrase, fin de paragraphe, fin de titre)
        last_good_break = max(
            segment.rfind(". "), segment.rfind("\n\n"), segment.rfind("\n#")
        )
        if last_good_break != -1:
            next_index = last_good_break + 1

        segments.append(text[:next_index])
        text = text[next_index:]

    return segments


def translate(text, client, args, use_mistral=False, is_translation_note=False):
    """
    Traduit un texte en utilisant les services de traduction d'OpenAI ou Mistral AI.
    Cette fonction segmente d'abord le texte pour s'assurer qu'il respecte la limite de tokens du modèle.
    Elle utilise un argument optionnel 'is_translation_note' pour gérer différemment les notes de traduction.

    Args:
        text (str): Texte à traduire.
        client: Client de l'API de traduction (OpenAI ou Mistral AI).
        args: Arguments contenant les informations de configuration.
        use_mistral (bool): Indique si l'API Mistral AI doit être utilisée (True) ou l'API OpenAI (False).
        is_translation_note (bool): Indique si le texte est une note de traduction, ce qui nécessite un traitement spécial.

    Returns:
        str: Texte traduit.
    """
    model_limit = MODEL_TOKEN_LIMITS.get(args.model, 4096)

    segments = segment_text(text, model_limit)
    translated_segments = []

    for segment in segments:
        try:
            prompt_message = ""
            if is_translation_note:
                prompt_message = f"Translate this exact sentence to {args.target_lang}, without any additions or explanations: '{segment}'"
            else:
                prompt_message = f"Please translate this text from {args.source_lang} to {args.target_lang}, and do not translate or change URLs, image paths, and code blocks (delimited by ```) : {segment}"

            if use_mistral:
                messages = [ChatMessage(role="user", content=prompt_message)]
                response = client.chat(model=args.model, messages=messages)
            else:
                messages = [
                    {"role": "system", "content": prompt_message},
                    {"role": "user", "content": segment},
                ]
                response = client.chat.completions.create(
                    model=args.model, messages=messages
                )
            translated_text = response.choices[0].message.content.strip()
        except Exception as e:
            raise RuntimeError(f"Erreur lors de la traduction : {e}")

        translated_segments.append(translated_text)

    return " ".join(translated_segments)


def add_translation_note(client, args, use_mistral):
    """
    Génère et traduit une note de traduction.

    Args:
        client: Objet client de traduction.
        args: Arguments contenant les informations de langue source et cible, et le modèle utilisé.
        use_mistral (bool): Indique si l'API Mistral AI doit être utilisée pour la traduction.

    Returns:
        str: Note de traduction traduite.
    """
    translation_note_src = f"Ce document a été traduit de la version {args.source_lang} par le modèle {args.model}."
    try:
        # Utiliser un prompt très spécifique pour Mistral AI
        if use_mistral:
            prompt_message = f"Translate this exact sentence to {args.target_lang}, without any additions or explanations: '{translation_note_src}'"
            messages = [ChatMessage(role="user", content=prompt_message)]
            response = client.chat(model=args.model, messages=messages)
            translated_note = response.choices[0].message.content.strip()
        else:
            # Pour OpenAI
            messages = [
                {
                    "role": "system",
                    "content": f"Translate this exact sentence to {args.target_lang}, without any additions or explanations: '{translation_note_src}'",
                },
                {"role": "user", "content": translation_note_src},
            ]
            response = client.chat.completions.create(
                model=args.model, messages=messages
            )
            translated_note = response.choices[0].essage.content.strip()

        return f"\n\n**{translated_note}**\n\n"
    except Exception as e:
        raise RuntimeError(f"Erreur lors de l'ajout de la note de traduction : {e}")


def translate_markdown_file(
    file_path, output_path, client, args, use_mistral, add_translation_note=False
):
    """
    Traduit un fichier Markdown en utilisant les modèles de traitement du langage naturel de OpenAI ou Mistral AI.

    Args:
        file_path (str): Chemin complet vers le fichier d'entrée.
        output_path (str): Chemin complet vers le fichier de sortie.
        client: Objet client de traduction.
        args: Arguments supplémentaires pour la traduction.
        use_mistral (bool): Indique si l'API Mistral AI doit être utilisée pour la traduction.
        add_translation_note (bool): Indique si une note de traduction doit être ajoutée.

    Returns:
        None
    """
    try:
        # Calcul des chemins relatifs pour un affichage plus lisible
        relative_file_path = os.path.join(
            args.source_dir, os.path.relpath(file_path, start=args.source_dir)
        )
        relative_output_path = os.path.join(
            args.target_dir, os.path.relpath(output_path, start=args.target_dir)
        )

        print(f"Traitement du fichier : {relative_file_path}")
        start_time = time.time()

        # Lecture du contenu du fichier
        with open(file_path, "r", encoding="utf-8") as f:
            content = f.read()

        # Extraction et remplacement temporaire des blocs de code pour éviter leur traduction
        code_blocks = re.findall(
            r"(^```[a-zA-Z]*\n.*?\n^```)", content, flags=re.MULTILINE | re.DOTALL
        )
        placeholders = [f"#CODEBLOCK{index}#" for index, _ in enumerate(code_blocks)]
        for placeholder, code_block in zip(placeholders, code_blocks):
            content = content.replace(code_block, placeholder)

        # Traduction du contenu
        translated_content = translate(content, client, args, use_mistral)

        # Restauration des blocs de code dans le contenu traduit
        for placeholder, code_block in zip(placeholders, code_blocks):
            translated_content = translated_content.replace(placeholder, code_block)

        # Ajout de la note de traduction si nécessaire
        if add_translation_note:
            translation_note = translate(
                "Ce document a été traduit de la version "
                + args.source_lang
                + " par le modèle "
                + args.model
                + ".",
                client,
                args,
                use_mistral,
                True,
            )
            translated_content += "\n\n**" + translation_note + "**\n\n"

        # Écriture du contenu traduit dans le fichier de sortie
        clean_output_path = os.path.normpath(output_path)
        with open(clean_output_path, "w", encoding="utf-8") as f:
            f.write(translated_content)

        end_time = time.time()
        print(
            f"Fichier '{relative_file_path}' traduit en {end_time - start_time:.2f} secondes et enregistré sous : {relative_output_path}"
        )
    except IOError as e:
        print(f"Erreur lors du traitement du fichier '{relative_file_path}': {e}")
    except Exception as e:
        print(
            f"Une erreur inattendue est survenue lors de la traduction du fichier '{relative_file_path}': {e}"
        )


def is_excluded(path):
    """
    Vérifie si le chemin donné correspond à l'un des motifs d'exclusion.

    Cette fonction parcourt la liste des motifs d'exclusion définis dans EXCLUDE_PATTERNS.
    Si l'un de ces motifs est trouvé dans le chemin fourni, la fonction renvoie True,
    indiquant que le chemin doit être exclu du processus de traduction.

    Args:
        path (str): Le chemin du fichier ou du répertoire à vérifier.

    Returns:
        bool: True si le chemin correspond à l'un des motifs d'exclusion, False sinon.
    """
    for pattern in EXCLUDE_PATTERNS:
        if pattern in path:
            return True
    return False


def translate_directory(
    input_dir, output_dir, client, args, use_mistral, add_translation_note
):
    """
    Traduit tous les fichiers markdown dans le répertoire d'entrée et ses sous-répertoires.

    Args:
        input_dir (str): Chemin vers le répertoire d'entrée.
        output_dir (str): Chemin vers le répertoire de sortie.
        client: Objet client de traduction.
        args: Arguments supplémentaires pour la traduction.
        use_mistral (bool): Indique si l'API Mistral AI doit être utilisée pour la traduction.
        add_translation_note (bool): Indique si une note de traduction doit être ajoutée.

    Returns:
        None
    """
    input_dir = os.path.abspath(input_dir)
    output_dir = os.path.abspath(output_dir)

    if not os.path.exists(output_dir):
        os.makedirs(output_dir)

    output_base_dir = os.path.basename(output_dir)

    for root, dirs, files in os.walk(input_dir, topdown=True):
        if is_excluded(root) or root.startswith(output_dir):
            continue

        if (
            os.path.basename(root) == output_base_dir
            and os.path.abspath(os.path.join(root, "..")) == input_dir
        ):
            continue

        for file in files:
            if file.endswith(".md") and not is_excluded(file):
                file_path = os.path.join(root, file)
                base, _ = os.path.splitext(file)
                output_file = f"{base}-{args.model}-{args.target_lang}.md"
                relative_path = os.path.relpath(root, input_dir)
                output_path = os.path.join(output_dir, relative_path, output_file)

                os.makedirs(os.path.dirname(output_path), exist_ok=True)

                if not os.path.exists(output_path):
                    translate_markdown_file(
                        file_path,
                        output_path,
                        client,
                        args,
                        use_mistral,
                        add_translation_note,
                    )
                    print(f"Fichier '{file}' traité.")


def main():
    """
    Point d'entrée principal du script de traduction de fichiers Markdown.

    Ce script traduit des fichiers Markdown d'une langue source à une langue cible en utilisant
    les services de traduction de l'API OpenAI ou Mistral AI. Il prend en charge la segmentation
    des textes longs et peut également ajouter une note de traduction en fin de document.

    Arguments du script:
    --source_dir: Répertoire contenant les fichiers Markdown à traduire.
    --target_dir: Répertoire de destination pour les fichiers traduits.
    --model: Modèle de traduction GPT à utiliser.
    --target_lang: Langue cible pour la traduction.
    --source_lang: Langue source des documents.
    --use_mistral: Indicateur pour utiliser l'API Mistral AI pour la traduction.
    --add_translation_note: Indicateur pour ajouter une note de traduction au contenu traduit.
    """
    parser = argparse.ArgumentParser(description="Traduit les fichiers Markdown.")
    parser.add_argument(
        "--source_dir",
        type=str,
        default=DEFAULT_SOURCE_DIR,
        help="Répertoire source contenant les fichiers Markdown",
    )
    parser.add_argument(
        "--target_dir",
        type=str,
        default=DEFAULT_TARGET_DIR,
        help="Répertoire cible pour sauvegarder les traductions",
    )
    parser.add_argument(
        "--model", type=str, help="Modèle GPT à utiliser pour la traduction"
    )
    parser.add_argument(
        "--target_lang",
        type=str,
        default=DEFAULT_TARGET_LANG,
        help="Langue cible pour la traduction",
    )
    parser.add_argument(
        "--source_lang",
        type=str,
        default=DEFAULT_SOURCE_LANG,
        help="Langue source pour la traduction",
    )
    parser.add_argument(
        "--use_mistral",
        action="store_true",
        help="Utiliser l'API Mistral AI pour la traduction",
    )
    parser.add_argument(
        "--add_translation_note",
        action="store_true",
        help="Ajouter une note de traduction au contenu traduit",
    )

    args = parser.parse_args()

    if not os.path.isdir(args.source_dir):
        raise ValueError(
            f"Le répertoire source spécifié n'existe pas : {args.source_dir}"
        )
    if not os.path.exists(args.target_dir):
        os.makedirs(args.target_dir)

    if args.use_mistral:
        args.model = args.model if args.model else DEFAULT_MODEL_MISTRAL
        api_key = os.getenv("MISTRAL_API_KEY", DEFAULT_MISTRAL_API_KEY)
        if not api_key:
            raise ValueError("Clé API Mistral non spécifiée.")
        client = MistralClient(api_key=api_key)
    else:
        args.model = args.model if args.model else DEFAULT_MODEL_OPENAI
        openai_api_key = os.getenv("OPENAI_API_KEY", DEFAULT_OPENAI_API_KEY)
        if not openai_api_key:
            raise ValueError("Clé API OpenAI non spécifiée.")
        client = OpenAI(api_key=openai_api_key)

    translate_directory(
        args.source_dir,
        args.target_dir,
        client,
        args,
        args.use_mistral,
        args.add_translation_note,
    )

    if args.use_mistral:
        try:
            del client
        except TypeError:
            pass


if __name__ == "__main__":
    main()

请继续关注更多关于人工智能有趣世界的更新和创新！

この記事では、人工知能を利用したブログ翻訳スクリプトの進化について、Mistral AI技術の統合を交えてお話しします。すべての言語での結果を確認するには、こちらのページをご覧ください：Mistral AIによる翻訳。

이 글에서는 인공지능을 사용한 블로그 번역 스크립트의 진화와 Mistral AI 기술 통합에 대해 이야기하겠습니다. 모든 언어로 된 결과를 보려면 이 페이지를 방문해 주세요: Mistral AI 번역.

इस लेख में, मैं कृत्रिम बुद्धिमत्ता का उपयोग करके अपने ब्लॉग अनुवाद स्क्रिप्ट के विकास के बारे में बात करूंगा, जिसमें मिस्त्रल एआई तकनीक का एकीकरण शामिल है। सभी भाषाओं में परिणाम देखने के लिए, कृपया इस पृष्ठ पर जाएं: मिस्त्रल एआई के साथ अनुवाद।

في هذه المقالة، سأتحدث عن تطور سكريبت ترجمة المدونة الخاص بي باستخدام الذكاء الاصطناعي، مع دمج تكنولوجيا Mistral AI. لاكتشاف النتائج بجميع اللغات، أدعوكم لزيارة هذه الصفحة: الترجمات مع Mistral AI.

I den här artikeln kommer jag att prata om utvecklingen av mitt bloggöversättningsscript som använder artificiell intelligens, med integrering av Mistral AI-teknologi. För att upptäcka resultaten på alla språk, besök denna sida: Översättningar med Mistral AI.

W tym artykule opowiem o ewolucji mojego skryptu tłumaczenia bloga z wykorzystaniem sztucznej inteligencji, integrując technologię Mistral AI. Aby odkryć wyniki we wszystkich językach, zapraszam na tę stronę: Tłumaczenia z Mistral AI.

In questo articolo, parlerò dell’evoluzione del mio script di traduzione del blog utilizzando l’intelligenza artificiale, con l’integrazione della tecnologia Mistral AI. Per scoprire i risultati in tutte le lingue, vi invito a visitare questa pagina: Traduzioni con Mistral AI.

In this article, I will talk to you about the evolution of my blog translation script using artificial intelligence, with the integration of Mistral AI technology. To discover the results in all languages, I invite you to visit this page: Translations with Mistral AI.

Why this Script?

The goal of my translation script is to make my blog articles accessible in several languages, by automating their translation. Imagine an intelligent translator capable of reading an article in French and restoring it faithfully in English, Spanish or other languages, while preserving the original format. That’s what my script does, by leveraging the latest advances in AI.

In this article, I will talk about the evolution of my blog translation script using artificial intelligence, with the integration of Mistral AI technology. To see results in all languages, I invite you to visit this page: Translations with Mistral AI.

In this article, I will talk about the evolution of my blog translation script using artificial intelligence, with the integration of Mistral AI technology. To discover the results in all languages, I invite you to visit this page: Translations with Mistral AI.

Dans cet article, je vais vous parler de l’évolution de mon script de traduction de blog utilisant l’intelligence artificielle, avec l’intégration de la technologie Mistral AI. Pour découvrir les résultats dans toutes les langues, je vous invite à visiter cette page : Traductions avec Mistral AI.

In dit artikel zal ik het hebben over de evolutie van mijn blogvertaalscript dat gebruikmaakt van kunstmatige intelligentie, met de integratie van de Mistral AI-technologie. Om de resultaten in alle talen te ontdekken, nodig ik je uit om deze pagina te bezoeken: Vertalingen met Mistral AI.

În acest articol, vă voi vorbi despre evoluția scriptului meu de traducere a blogului utilizând inteligența artificială, cu integrarea tehnologiei Mistral AI. Pentru a descoperi rezultatele în toate limbile, vă invit să vizitați această pagină: Traduceri cu Mistral AI.

En este artículo, te hablaré sobre la evolución de mi script de traducción de blog utilizando la inteligencia artificial, con la integración de la tecnología Mistral AI. Para descubrir los resultados en todos los idiomas, te invito a visitar esta página: Traducciones con Mistral AI.

Por qué este Script?

El objetivo de mi script de traducción es hacer que mis artículos de blog sean accesibles en varios idiomas, automatizando su traducción. Imagina un traductor inteligente capaz de leer un artículo en francés y devolverlo fielmente en inglés, español u otros idiomas, manteniendo el formato original. Eso es lo que hace mi script, aprovechando los últimos avances de la IA.

En este artículo, voy a hablarles sobre la evolución de mi script de traducción de blog que utiliza la inteligencia artificial, con la integración de la tecnología Mistral AI. Para descubrir los resultados en todos los idiomas, les invito a visitar esta página: Traducciones con Mistral AI.

En este artículo, les hablaré sobre la evolución de mi script de traducción de blog utilizando la inteligencia artificial, con la integración de la tecnología Mistral AI. Para descubrir los resultados en todos los idiomas, los invito a visitar esta página: Traducciones con Mistral AI.

Neste artigo, vou falar sobre a evolução do meu script de tradução de blog utilizando a inteligência artificial, com a integração da tecnologia Mistral AI. Para descobrir os resultados em todas as línguas, eu convido você a visitar esta página: Traduções com Mistral AI.

In diesem Artikel werde ich über die Entwicklung meines Blog-Übersetzungsskripts unter Verwendung künstlicher Intelligenz sprechen, mit der Integration der Technologie von Mistral AI. Um die Ergebnisse in allen Sprachen zu sehen, lade ich Sie ein, diese Seite zu besuchen: Übersetzungen mit Mistral AI.

在这篇文章中，我分享了一个作为概念验证（POC）开发的Python脚本，用于自动化翻译我的博客帖子，利用OpenAI的GPT-4语言模型。这个脚本专为处理我的Hugo博客结构中的Markdown文件设计，使管理我的文章的多语言变得更加容易。这些文章可用英语、西班牙语和中文查阅。

在这篇文章中，我分享了一个作为概念证明（POC）开发的Python脚本，用于自动化翻译我的博客文章，使用OpenAI的GPT-4语言模型。这个脚本专门设计用于处理Hugo博客的Markdown文件结构，便于管理多语言文章。它们可以在英文、西班牙文和中文中获得。

在这篇文章中，我分享了一个Python脚本，作为一个概念验证(POC)，使用OpenAI的GPT-4语言模型自动翻译我的博客文章。这个脚本专门设计用于处理我的Hugo博客结构中的Markdown文件，方便管理我文章的多语言版本。它们有英文、西班牙文和中文版本。

この記事では、OpenAI の GPT-4 言語モデルを使用してブログの投稿を自動翻訳するために作成された Proof of Concept (POC) 用の Python スクリプトを共有します。このスクリプトは、Hugo ブログ構造内の Markdown ファイルを処理するために特別に設計されており、記事の多言語管理を容易にします。これらの記事は 英語、スペイン語、中国語 で利用可能です。

이 기사에서는 OpenAI의 GPT-4 언어 모델을 사용하여 블로그 게시물의 번역을 자동화하기 위해 개발된 Proof of Concept (POC) Python 스크립트를 공유합니다. 이 스크립트는 특히 제 Hugo 블로그 구조에서 Markdown 파일을 처리하도록 설계되어 다국어 관리가 용이합니다. 이들은 영어, 스페인어, 중국어로 제공됩니다.

इस लेख में, मैं एक पीओसी (प्रूफ़ ऑफ़ कॉन्सेप्ट) के रूप में एक पाइथन स्क्रिप्ट साझा कर रहा हूँ, जो ओपनएआई के GPT-4 भाषा मॉडल का उपयोग करके मेरे ब्लॉग पोस्टों के अनुवाद को स्वचालित करने के लिए विकसित की गई है। यह स्क्रिप्ट विशेष रूप से मेरे ह्यूगो ब्लॉग की संरचना में मार्कडाउन फाइलों को प्रोसेस करने के लिए डिज़ाइन की गई है, जिससे मेरे लेखों की बहुभाषी प्रबंधन में सुविधा हो। वे अंग्रेजी, स्पेनिश और चीनी में उपलब्ध हैं।

في هذه المقالة، أشارك سكربت بايثون طورته كعرض مفهوم (POC) لأتمتة ترجمة منشورات مدونتي، باستخدام نموذج اللغة GPT-4 من OpenAI. هذا السكربت مصمم خصيصاً لمعالجة ملفات Markdown في هيكل مدونتي Hugo، مما يسهل إدارة المقالات متعددة اللغات. وهي متاحة باللغات الإنجليزية، الإسبانية و الصينية.

In questo articolo, condivido uno script Python sviluppato come Proof of Concept (POC) per automatizzare la traduzione dei post del mio blog, utilizzando il modello di linguaggio GPT-4 di OpenAI. Questo script è specificamente progettato per trattare file Markdown nella struttura del mio blog Hugo, facilitando la gestione multilingue dei miei articoli. Sono disponibili in Inglese, Spagnolo e Cinese.

W tym artykule dzielę się skryptem Python opracowanym jako Proof of Concept (POC) do automatyzacji tłumaczeń postów mojego bloga, wykorzystując model językowy GPT-4 od OpenAI. Ten skrypt jest specjalnie zaprojektowany do przetwarzania plików Markdown w strukturze mojego bloga Hugo, ułatwiając zarządzanie wielojęzycznymi artykułami. Są one dostępne po Angielsku, Hiszpańsku i Chińsku.

Dans cet article, je partage un script Python développé comme un Proof of Concept (POC) pour automatiser la traduction des posts de mon blog, en utilisant le modèle de langage GPT-4 d’OpenAI. Ce script est spécifiquement conçu pour traiter des fichiers Markdown dans la structure de mon blog Hugo, facilitant la gestion multilingue de mes articles. Ils sont disponibles en Anglais, Espagnol et Chinois.

In this article, I share a Python script developed as a Proof of Concept (POC) to automate the translation of my blog posts using OpenAI’s GPT-4 language model. This script is specifically designed to handle Markdown files in the structure of my Hugo blog, making it easy to manage multilingual articles. They are available in English, Spanish, and Chinese.

In this article, I share a Python script developed as a Proof of Concept (POC) to automate the translation of my blog posts, using OpenAI’s GPT-4 language model. This script is specifically designed to process Markdown files in my Hugo blog’s structure, facilitating multilingual management of my articles. They are available in English, Spanish and Chinese.

In this article, I share a Python script developed as a Proof of Concept (POC) for automating the translation of my blog posts, using OpenAI’s GPT-4 language model. This script is specifically designed to process Markdown files in the structure of my Hugo blog, facilitating the multilingual management of my articles. They are available in English, Spanish and Chinese.

In diesem Artikel teile ich ein Python-Skript, das als Proof of Concept (POC) entwickelt wurde, um die Übersetzung meiner Blogbeiträge zu automatisieren, indem das Sprachmodell GPT-4 von OpenAI verwendet wird. Dieses Skript ist speziell darauf ausgelegt, Markdown-Dateien in der Struktur meines Hugo-Blogs zu verarbeiten und die mehrsprachige Verwaltung meiner Artikel zu erleichtern. Sie sind verfügbar in Englisch, Spanisch und Chinesisch.

I den här artikeln delar jag ett Python-skript utvecklat som ett Proof of Concept (POC) för att automatisera översättningen av mina blogginlägg, med hjälp av OpenAI:s GPT-4 språkmodell. Detta skript är specifikt utformat för att hantera Markdown-filer i strukturen av min Hugo-blogg, vilket underlättar flerspråkig hantering av mina artiklar. De finns tillgängliga på Engelska, Spanska och Kinesiska.

În acest articol, împărtășesc un script Python dezvoltat ca un Proof of Concept (POC) pentru automatizarea traducerii postărilor de pe blogul meu, folosind modelul de limbaj GPT-4 de la OpenAI. Acest script este special conceput pentru a procesa fișiere Markdown în structura blogului meu Hugo, facilitând gestionarea multilingvă a articolelor mele. Ele sunt disponibile în Engleză, Spaniolă și Chineză.

In dit artikel deel ik een Python-script dat ontwikkeld is als een Proof of Concept (POC) om de vertaling van mijn blogposts te automatiseren, met behulp van het GPT-4-taalmodel van OpenAI. Dit script is specifiek ontworpen om Markdown-bestanden in de structuur van mijn Hugo-blog te verwerken, wat het beheer van meertalige artikelen vergemakkelijkt. Ze zijn beschikbaar in het Engels, Spaans en Chinees.

En este artículo, comparto un script de Python desarrollado como una Prueba de Concepto (POC) para automatizar la traducción de las entradas de mi blog, utilizando el modelo de lenguaje GPT-4 de OpenAI. Este script está específicamente diseñado para procesar archivos Markdown en la estructura de mi blog Hugo, facilitando la gestión multilingüe de mis entradas. Están disponibles en Inglés, Español y Chino.

En este artículo, comparto un script Python desarrollado como un Proof of Concept (POC) para automatizar la traducción de posts de mi blog, utilizando el modelo de lenguaje GPT-4 de OpenAI. Este script está diseñado específicamente para tratar archivos Markdown en la estructura de mi blog Hugo, facilitando la gestión multilingüe de mis artículos. Están disponibles en Inglés, Español y Chino.

En este artículo, comparto un script de Python desarrollado como una Prueba de Concepto (POC) para automatizar la traducción de las publicaciones de mi blog, utilizando el modelo de lenguaje GPT-4 de OpenAI. Este script está específicamente diseñado para procesar archivos Markdown en la estructura de mi blog Hugo, facilitando la gestión multilingüe de mis artículos. Están disponibles en Inglés, Español y Chino.

Neste artigo, compartilho um script Python desenvolvido como uma Prova de Conceito (POC) para automatizar a tradução dos posts do meu blog, utilizando o modelo de linguagem GPT-4 da OpenAI. Este script é especificamente projetado para tratar arquivos Markdown na estrutura do meu blog Hugo, facilitando a gestão multilíngue dos meus artigos. Eles estão disponíveis em Inglês, Espanhol e Chinês.