@intlayer/docs 9.0.0-canary.4 → 9.0.0-canary.5

package/blog/hi/rag_powered_documentation_assistant.md

@@ -313,3 +313,16 @@ RAG LLMs को व्यावहारिक बनाने के सबस
 </Step>
 
 </Steps>
+## निष्कर्ष
+
+RAG LLMs को व्यावहारिक बनाने के सबसे सरल और शक्तिशाली तरीकों में से एक है। **retrieval + generation** को जोड़कर, आप स्टेटिक docs को एक **smart assistant** में बदल सकते हैं और साथ ही product insights की एक सतत stream प्राप्त कर सकते हैं।
+
+मेरे लिए, इस project ने दिखाया कि RAG सिर्फ एक तकनीकी trick नहीं है। यह documentation को इसमें बदलने का एक तरीका है:
+
+- एक interactive support system
+- एक feedback channel
+- एक product strategy tool
+
+👉 [Demo को यहाँ आजमाएं](https://intlayer.org/doc/why) 👉 [GitHub पर code template देखें](https://github.com/aymericzip/smart_doc_RAG)
+
+और अगर आप भी RAG के साथ experiment कर रहे हैं, तो मुझे सुनना अच्छा लगेगा कि आप इसे कैसे use कर रहे हैं।

package/blog/hi/react-i18next_vs_react-intl_vs_intlayer.md

@@ -146,6 +146,12 @@ author: aymericzip
 
 ---
 
+## GitHub STARs
+
+GitHub stars एक प्रोजेक्ट की लोकप्रियता, कम्युनिटी के विश्वास और दीर्घकालीन प्रासंगिकता का एक मजबूत संकेतक हैं। हालांकि तकनीकी गुणवत्ता का सीधा माप नहीं, वे दर्शाते हैं कि कितने developers को प्रोजेक्ट उपयोगी लगता है, इसकी प्रगति का अनुसरण करते हैं, और इसे अपनाने की संभावना रखते हैं। किसी प्रोजेक्ट के मूल्य का अनुमान लगाने के लिए, stars विकल्पों के बीच traction की तुलना करने और ecosystem growth में insights प्रदान करने में मदद करते हैं।
+
+[![Star History Chart](https://api.star-history.com/chart?repos=formatjs/formatjs%2Ci18next/react-i18next%2Caymericzip/intlayer&type=date&legend=top-left)](https://www.star-history.com/#formatjs/formatjs&i18next/react-i18next&aymericzip/intlayer)
+
 ## निष्कर्ष
 
 तीनों पुस्तकालय React को प्रभावी ढंग से स्थानीयकृत करते हैं। अंतर यह है कि आपको एक **सुरक्षित, स्केलेबल** सेटअप तक पहुंचने के लिए कितना **इन्फ्रास्ट्रक्चर** बनाना होगा:

package/blog/hi/vue-i18n_vs_intlayer.md

@@ -249,6 +249,14 @@ const { greeting } = useIntlayer("component-example");
 
 ---
 
+## vue-i18n के साथ अंतरसंचालनीयता
+
+`intlayer` आपके `vue-i18n` namespaces को प्रबंधित करने में भी मदद कर सकता है।
+
+`intlayer` का उपयोग करके, आप अपने पसंदीदा i18n library के प्रारूप में अपनी content declare कर सकते हैं, और intlayer आपकी namespaces को अपनी पसंद के स्थान पर generate करेगा (उदाहरण: `/messages/{{locale}}/{{namespace}}.json`)।
+
+---
+
 ## व्यावहारिक माइग्रेशन नोट्स (vue-i18n → Intlayer)
 
 - **प्रत्येक फीचर से शुरू करें**: एक समय में एक रूट/व्यू/कंपोनेंट को स्थानीय Intlayer शब्दकोशों में स्थानांतरित करें।

package/blog/id/internationalization_and_SEO.md

@@ -88,101 +88,10 @@ Dalam HTML Anda, tambahkan sesuatu seperti:
 
 ## 4. Membuat Konten Benar-Benar “Lokal” (Bukan Sekadar Diterjemahkan)
 
-### 4.1. Lokalisasi vs. Terjemahan
-
-- **Terjemahan** berarti mengubah teks dari satu bahasa ke bahasa lain secara kata per kata.
-- **Lokalisasi** berarti menyesuaikan format konten, mata uang, ukuran, dan referensi budaya untuk audiens lokal. Misalnya, jika Anda menargetkan Prancis, Anda akan menggunakan `€` alih-alih `---
-  createdAt: 2024-12-24
-  updatedAt: 2025-06-29
-  title: SEO dan Internasionalisasi
-  description: Temukan cara mengoptimalkan situs web multibahasa Anda untuk mesin pencari dan meningkatkan SEO Anda.
-  keywords:
-  - SEO
-  - Intlayer
-  - Internasionalisasi
-  - Blog
-  - Next.js
-  - JavaScript
-  - React
-    slugs:
-  - blog
-  - SEO-and-i18n
-
----
-
-# SEO & I18n: Panduan Utama untuk Membuat Situs Web Anda Multibahasa
-
-Ingin menjangkau lebih banyak pengguna di seluruh dunia? Membuat situs web Anda menjadi multibahasa adalah salah satu cara terbaik untuk memperluas audiens Anda dan meningkatkan SEO (Search Engine Optimization) Anda. Dalam posting blog ini, kami akan menguraikan dasar-dasar SEO internasional yang sering disebut sebagai **i18n** (singkatan dari "internasionalisasi"), dengan istilah yang jelas dan mudah dipahami. Anda akan mempelajari keputusan kunci yang perlu Anda buat, cara menggunakan elemen teknis seperti `hreflang`, dan mengapa alat seperti **Intlayer** dapat menyederhanakan proyek Next.js multibahasa Anda.
-
----
-
-## 1. Apa Arti Membuat Situs Web Anda Menjadi Multibahasa?
-
-Situs web multibahasa menawarkan kontennya dalam lebih dari satu bahasa. Misalnya, Anda mungkin memiliki versi bahasa Inggris (`example.com/en/`), versi bahasa Prancis (`example.com/fr/`), dan versi bahasa Spanyol (`example.com/es/`). Pendekatan ini memungkinkan mesin pencari menampilkan versi bahasa yang tepat kepada pengguna berdasarkan preferensi atau lokasi geografis mereka.
-
-Ketika Anda melakukannya dengan benar, Anda akan menciptakan pengalaman yang jauh lebih ramah pengguna bagi penutur non-Inggris yang mengarah pada keterlibatan yang lebih baik, tingkat konversi yang lebih tinggi, dan peningkatan SEO di berbagai wilayah.
-
----
-
-## 2. Memilih Struktur URL yang Tepat
-
-Jika Anda memutuskan untuk memiliki beberapa versi bahasa, Anda memerlukan cara yang jelas dan konsisten untuk mengatur URL situs Anda. Setiap bahasa (atau wilayah) harus memiliki “alamat” uniknya sendiri di internet. Berikut adalah tiga cara umum untuk menyusun situs web multibahasa:
-
-1. Domain Tingkat Atas Kode Negara (ccTLD)
-   - Contoh: `example.fr`, `example.de`
-   - **Kelebihan:** Mengirim sinyal kuat ke mesin pencari tentang negara mana konten tersebut ditargetkan (misalnya, `.fr` = Prancis).
-   - **Kekurangan:** Mengelola beberapa domain bisa lebih mahal dan rumit.
-
-2. **Subdomain**
-   - **Contoh:** `fr.example.com`, `de.example.com`
-   - **Kelebihan:** Setiap bahasa “tinggal” di subdomainnya sendiri, sehingga relatif mudah untuk menambah atau menghapus bahasa.
-   - **Kekurangan:** Mesin pencari terkadang memperlakukan subdomain sebagai situs yang terpisah, sehingga dapat mengurangi otoritas domain utama Anda.
-
-3. **Subdirektori (Subfolder)**
-   - **Contoh:** `example.com/fr/`, `example.com/de/`
-   - **Kelebihan:** Mudah dikelola, dan semua lalu lintas diarahkan ke satu domain utama.
-   - **Kekurangan:** Sinyal SEO lokal tidak sekuat ccTLD (meskipun masih sangat efektif jika dilakukan dengan benar).
-
-> **Tips:** Jika Anda memiliki merek global dan ingin menjaga semuanya tetap sederhana, subdirektori seringkali menjadi pilihan terbaik. Jika Anda hanya menargetkan satu atau dua negara utama dan ingin benar-benar menekankan masing-masing, ccTLD mungkin menjadi pilihan yang tepat.
-
----
-
-## 3. Menguasai Penargetan Bahasa dengan Hreflang
-
 ### 3.1. Apa Itu Hreflang?
 
 Ketika Anda memiliki konten yang identik atau sangat mirip dalam beberapa bahasa, mesin pencari seperti Google bisa bingung versi mana yang harus ditampilkan kepada pengguna. **Hreflang** adalah atribut HTML yang memberi tahu mesin pencari bahasa (dan wilayah) mana yang ditujukan untuk halaman tertentu, serta halaman alternatif bahasa/ wilayah lainnya.
 
-### 3.2. Mengapa Ini Penting?
-
-1. Mencegah masalah **konten duplikat** (ketika mesin pencari mengira Anda menerbitkan konten yang sama berkali-kali).
-2. Memastikan **pengguna Prancis melihat versi bahasa Prancis**, **pengguna Spanyol melihat versi bahasa Spanyol**, dan seterusnya.
-3. Meningkatkan pengalaman pengguna secara keseluruhan, yang berarti keterlibatan lebih baik dan peringkat SEO yang lebih tinggi.
-
-### 3.3. Cara Menggunakan Hreflang di Tag `<head>`
-
-Dalam HTML Anda, tambahkan sesuatu seperti:
-
-```html
-<link rel="alternate" hreflang="en" href="https://example.com/en" />
-<link rel="alternate" hreflang="fr" href="https://example.com/fr" />
-<link rel="alternate" hreflang="es" href="https://example.com/es" />
-<link rel="alternate" hreflang="x-default" href="https://example.com/en" />
-```
-
-- **`hreflang="en"`**: Menunjukkan versi bahasa Inggris dari halaman tersebut.
-- **`hreflang="fr"`**: Menunjukkan versi bahasa Prancis dari halaman tersebut.
-- **`hreflang="es"`**: Menunjukkan versi bahasa Spanyol dari halaman tersebut.
-- **`hreflang="x-default"`**: Bahasa “fallback” atau URL default ketika tidak ada bahasa lain yang cocok dengan preferensi pengguna.
-
-> **Catatan Cepat:** Pastikan URL dalam tag ini langsung mengarah ke halaman akhir, tanpa pengalihan tambahan apapun.
-
----
-
-## 4. Membuat Konten Benar-Benar “Lokal” (Bukan Sekadar Diterjemahkan)
-
-, dan mungkin menyebutkan hari libur lokal atau detail khusus wilayah.
-
 ### 4.2. Menghindari Konten Duplikat
 
 Meskipun terjemahan sudah baik, mesin pencari dapat menandai situs Anda sebagai konten duplikat jika tampilannya terlalu mirip secara struktur. Hreflang membantu memperjelas bahwa halaman-halaman ini bukan duplikat, melainkan variasi bahasa.

package/blog/id/intlayer_with_i18next.md

@@ -34,6 +34,10 @@ author: aymericzip
 
 <iframe title="Cara mengotomatisasi terjemahan JSON i18next Anda menggunakan Intlayer" class="m-auto aspect-16/9 w-full overflow-hidden rounded-lg border-0" allow="autoplay; gyroscope;" loading="lazy" width="1080" height="auto" src="https://www.youtube.com/embed/MpGMxniDHNg?autoplay=0&amp;origin=https://intlayer.org&amp;controls=0&amp;rel=1"/>
 
+## Daftar Isi
+
+<TOC/>
+
 ## Apa itu Intlayer?
 
 **Intlayer** adalah perpustakaan internasionalisasi sumber terbuka yang inovatif, dirancang untuk mengatasi kekurangan solusi i18n tradisional. Ini menawarkan pendekatan modern untuk manajemen konten dalam aplikasi JavaScript.

package/blog/id/intlayer_with_next-i18next.md

@@ -34,17 +34,6 @@ author: aymericzip
 
 <TOC/>
 
-## Apa itu next-i18next?
-
-**next-i18next** adalah salah satu kerangka kerja internasionalisasi (i18n) yang paling populer untuk aplikasi Next.js. Dibangun di atas ekosistem **i18next** yang kuat, ia menyediakan solusi komprehensif untuk mengelola terjemahan, lokalisasi, dan pergantian bahasa dalam proyek Next.js.
-
-Namun, next-i18next memiliki beberapa tantangan:
-
-- **Konfigurasi yang kompleks**: Mengatur next-i18next memerlukan beberapa file konfigurasi dan penyiapan yang cermat untuk instance i18n di sisi server dan klien.
-- **Terjemahan yang tersebar**: File terjemahan biasanya disimpan di direktori yang terpisah dari komponen, sehingga lebih sulit untuk menjaga konsistensi.
-- **Manajemen namespace manual**: Pengembang perlu mengelola namespace secara manual dan memastikan pemuatan sumber daya terjemahan yang tepat.
-- **Keamanan tipe terbatas**: Dukungan TypeScript memerlukan konfigurasi tambahan dan tidak menyediakan pembuatan tipe otomatis untuk terjemahan.
-
 ## Apa itu Intlayer?
 
 **Intlayer** adalah perpustakaan internasionalisasi sumber terbuka yang inovatif, dirancang untuk mengatasi kekurangan solusi i18n tradisional. Ini menawarkan pendekatan modern untuk manajemen konten dalam aplikasi Next.js.

package/blog/id/intlayer_with_next-intl.md

@@ -29,6 +29,10 @@ author: aymericzip
 
 <iframe title="Cara mengotomatisasi terjemahan JSON next-intl Anda menggunakan Intlayer" class="m-auto aspect-16/9 w-full overflow-hidden rounded-lg border-0" allow="autoplay; gyroscope;" loading="lazy" width="1080" height="auto" src="https://www.youtube.com/embed/MpGMxniDHNg?autoplay=0&amp;origin=https://intlayer.org&amp;controls=0&amp;rel=1"/>
 
+# Daftar Isi
+
+<TOC/>
+
 ## Apa itu Intlayer?
 
 **Intlayer** adalah perpustakaan internasionalisasi sumber terbuka yang inovatif, dirancang untuk mengatasi kekurangan solusi i18n tradisional. Ini menawarkan pendekatan modern untuk manajemen konten dalam aplikasi Next.js.

package/blog/id/rag_powered_documentation_assistant.md

@@ -317,3 +317,16 @@ Dan jika Anda juga bereksperimen dengan RAG, saya ingin sekali mendengar bagaima
 </Step>
 
 </Steps>
+## Kesimpulan
+
+RAG adalah salah satu cara paling sederhana dan paling kuat untuk membuat LLM praktis. Dengan menggabungkan **retrieval + generation**, Anda dapat mengubah docs statis menjadi **smart assistant** dan, pada saat yang sama, mendapatkan aliran wawasan produk yang berkelanjutan.
+
+Bagi saya, proyek ini menunjukkan bahwa RAG bukan hanya trik teknis. Ini adalah cara untuk mengubah dokumentasi menjadi:
+
+- sistem dukungan interaktif
+- saluran umpan balik
+- alat strategi produk
+
+👉 [Coba demo di sini](https://intlayer.org/doc/why) 👉 [Periksa template kode di GitHub](https://github.com/aymericzip/smart_doc_RAG)
+
+Dan jika Anda juga bereksperimen dengan RAG, saya ingin mendengar bagaimana Anda menggunakannya.

package/blog/it/intlayer_with_i18next.md

@@ -34,6 +34,10 @@ author: aymericzip
 
 <iframe title="Come automatizzare le traduzioni JSON di i18next usando Intlayer" class="m-auto aspect-16/9 w-full overflow-hidden rounded-lg border-0" allow="autoplay; gyroscope;" loading="lazy" width="1080" height="auto" src="https://www.youtube.com/embed/MpGMxniDHNg?autoplay=0&amp;origin=https://intlayer.org&amp;controls=0&amp;rel=1"/>
 
+## Indice
+
+<TOC/>
+
 ## Cos'è Intlayer?
 
 **Intlayer** è una libreria di internazionalizzazione innovativa e open-source progettata per superare le limitazioni delle soluzioni i18n tradizionali. Offre un approccio moderno alla gestione dei contenuti nelle applicazioni JavaScript.

package/blog/it/intlayer_with_next-i18next.md

@@ -34,17 +34,6 @@ author: aymericzip
 
 <TOC/>
 
-## Cos'è next-i18next?
-
-**next-i18next** è uno dei framework di internazionalizzazione (i18n) più popolari per le applicazioni Next.js. Costruito sopra il potente ecosistema **i18next**, offre una soluzione completa per la gestione delle traduzioni, della localizzazione e del cambio lingua nei progetti Next.js.
-
-Tuttavia, next-i18next presenta alcune sfide:
-
-- **Configurazione complessa**: Configurare next-i18next richiede più file di configurazione e un'attenta impostazione delle istanze i18n sia lato server che lato client.
-- **Traduzioni sparse**: I file di traduzione sono tipicamente archiviati in directory separate dai componenti, rendendo più difficile mantenere la coerenza.
-- **Gestione manuale dei namespace**: Gli sviluppatori devono gestire manualmente i namespace e assicurarsi del corretto caricamento delle risorse di traduzione.
-- **Sicurezza dei tipi limitata**: Il supporto a TypeScript richiede una configurazione aggiuntiva e non fornisce una generazione automatica dei tipi per le traduzioni.
-
 ## Cos'è Intlayer?
 
 **Intlayer** è una libreria di internazionalizzazione innovativa e open-source progettata per affrontare le carenze delle soluzioni i18n tradizionali. Offre un approccio moderno alla gestione dei contenuti nelle applicazioni Next.js.

package/blog/it/intlayer_with_next-intl.md

@@ -29,6 +29,10 @@ author: aymericzip
 
 <iframe title="Come automatizzare le traduzioni JSON di next-intl usando Intlayer" class="m-auto aspect-16/9 w-full overflow-hidden rounded-lg border-0" allow="autoplay; gyroscope;" loading="lazy" width="1080" height="auto" src="https://www.youtube.com/embed/MpGMxniDHNg?autoplay=0&amp;origin=https://intlayer.org&amp;controls=0&amp;rel=1"/>
 
+# Indice dei contenuti
+
+<TOC/>
+
 ## Cos'è Intlayer?
 
 **Intlayer** è una libreria di internazionalizzazione innovativa e open-source progettata per superare le limitazioni delle soluzioni i18n tradizionali. Offre un approccio moderno alla gestione dei contenuti nelle applicazioni Next.js.

package/blog/it/next-i18next_vs_next-intl_vs_intlayer.md

@@ -61,14 +61,6 @@ Ci concentriamo su **Next.js 13+ App Router** (con **React Server Components**)
 
 ---
 
-## Confronto delle funzionalità affiancate (focalizzato su Next.js)
-
-| Funzionalità | `next-intlayer` (Intlayer) | `next-intl` | `next-i18next` |
-
-> I badge si aggiornano automaticamente. Gli snapshot varieranno nel tempo.
-
----
-
 ## Confronto delle Funzionalità Affiancate (focalizzato su Next.js)
 
 | Funzionalità                                            | `next-intlayer` (Intlayer)                                                                                                                     | `next-intl`                                                                                                                      | `next-i18next`                                                                                                                   |
@@ -288,34 +280,6 @@ Ecco un esempio dell'impatto dell'ottimizzazione della dimensione del bundle uti
 
 ---
 
-## DX, strumenti e manutenzione
-
-<Columns>
-  <Column>
-
-**next-intl**
-
-- Comunemente abbinato a piattaforme di localizzazione esterne e flussi editoriali.
-
-  </Column>
-  <Column>
-
-**next-i18next**
-
-- Comunemente abbinato a piattaforme di localizzazione esterne e flussi editoriali.
-
-  </Column>
-  <Column>
-
-**intlayer**
-
-- Fornisce un **Editor Visivo gratuito** e un **CMS opzionale** (compatibile con Git o esternalizzato), oltre a un’**estensione VSCode** e **traduzioni assistite da AI** utilizzando le tue chiavi provider.
-
-  </Column>
-</Columns>
-
-**Perché è importante:** Riduce i costi operativi e accorcia il ciclo tra sviluppatori e autori dei contenuti.
-
 ## Integrazione con piattaforme di localizzazione (TMS)
 
 Le grandi organizzazioni spesso si affidano a Sistemi di Gestione delle Traduzioni (TMS) come **Crowdin**, **Phrase**, **Lokalise**, **Localizely** o **Localazy**.
@@ -1182,6 +1146,127 @@ export default robots;
 
 ---
 
+### Middleware per il routing delle lingue
+
+<Tabs defaultTab="next-intl" group='techno'>
+  <Tab label="next-i18next" value="next-i18next">
+
+Aggiungi un middleware per gestire il rilevamento delle lingue e il routing:
+
+```ts fileName="src/middleware.ts"
+import { NextResponse, type NextRequest } from "next/server";
+import { defaultLocale, locales } from "@/i18n.config";
+
+const PUBLIC_FILE = /\.[^/]+$/; // esclude i file con estensioni
+
+export function middleware(request: NextRequest) {
+  const { pathname } = request.nextUrl;
+
+  if (
+    pathname.startsWith("/_next") ||
+    pathname.startsWith("/api") ||
+    pathname.startsWith("/static") ||
+    PUBLIC_FILE.test(pathname)
+  ) {
+    return;
+  }
+
+  const hasLocale = locales.some(
+    (l) => pathname === "/" + l || pathname.startsWith("/" + l + "/")
+  );
+  if (!hasLocale) {
+    const locale = defaultLocale;
+    const url = request.nextUrl.clone();
+    url.pathname = "/" + locale + (pathname === "/" ? "" : pathname);
+    return NextResponse.redirect(url);
+  }
+}
+
+export const config = {
+  matcher: [
+    // Corrisponde a tutti i percorsi tranne quelli che iniziano con questi e i file con un'estensione
+    "/((?!api|_next|static|.*\\..*).*)",
+  ],
+};
+```
+
+  </Tab>
+  <Tab label="next-intl" value="next-intl">
+
+Aggiungi un middleware per gestire il rilevamento delle lingue e il routing:
+
+```ts fileName="src/middleware.ts"
+import createMiddleware from "next-intl/middleware";
+import { locales, defaultLocale } from "@/i18n";
+
+export default createMiddleware({
+  locales: [...locales],
+  defaultLocale,
+  localeDetection: true,
+});
+
+export const config = {
+  // Salta API, Next internals e asset statici
+  matcher: ["/((?!api|_next|.*\\..*).*)"],
+};
+```
+
+  </Tab>
+  <Tab label="intlayer" value="intlayer">
+
+Intlayer fornisce la gestione del middleware integrata attraverso la configurazione del package `next-intlayer`.
+
+```ts fileName="src/middleware.ts"
+import { intlayerProxy } from "next-intlayer/proxy";
+
+export const middleware = intlayerProxy();
+
+// applica questo middleware solo ai file nella directory app
+export const config = {
+  matcher: "/((?!api|_next|static|.*\\..*).*)",
+};
+```
+
+La configurazione del middleware è centralizzata nel file `intlayer.config.ts`.
+
+  </Tab>
+</Tabs>
+
+### Checklist di configurazione e buone pratiche
+
+<Tabs defaultTab="next-intl" group='techno'>
+  <Tab label="next-i18next" value="next-i18next">
+
+- Assicurati che `lang` e `dir` siano impostati su root `<html>` in `src/app/[locale]/layout.tsx`.
+- Dividi le traduzioni in namespace (ad esempio `common.json`, `about.json`) sotto `src/locales/<locale>/`.
+- Carica solo i namespace richiesti nei componenti client utilizzando `useTranslation('<ns>')` e limitando il scope di `I18nProvider` agli stessi namespace.
+- Mantieni le pagine statiche quando possibile: esporta `export const dynamic = 'force-static'` nelle pagine; imposta `dynamicParams = false` e implementa `generateStaticParams`.
+- Utilizza componenti server sincronizzati annidati sotto i confini client passando stringhe già calcolate o la funzione `t` e la `locale`.
+- Per SEO, imposta `alternates.languages` nei metadati, elenca gli URL localizzati in `sitemap.ts` e disabilita le rotte localizzate duplicate in `robots.ts`.
+- Preferisci i formatter consapevoli della locale (ad esempio `Intl.NumberFormat(locale)`) e memoizzali sul client se usi React < 19.
+
+  </Tab>
+  <Tab label="next-intl" value="next-intl">
+
+- **Imposta l'`lang` e il `dir` dell'html**: In `src/app/[locale]/layout.tsx`, calcola `dir` tramite `getLocaleDirection(locale)` e imposta `<html lang={locale} dir={dir}>`.
+- **Dividi i messaggi per namespace**: Organizza il JSON per locale e namespace (ad esempio `common.json`, `about.json`).
+- **Minimizza il payload client**: Nelle pagine, invia solo i namespace richiesti a `NextIntlClientProvider` (ad esempio `pick(messages, ['common', 'about'])`).
+- **Preferisci pagine statiche**: Esporta `export const dynamic = 'force-static'` e genera parametri statici per tutte le `locales`.
+- **Componenti server sincronizzati**: Mantieni i componenti server sincronizzati passando stringhe precalcolate (etichette tradotte, numeri formattati) piuttosto che chiamate asincrone o funzioni non serializzabili.
+
+  </Tab>
+  <Tab label="intlayer" value="intlayer">
+
+- **Contenuto modulare**: Coloca i dizionari di contenuto insieme ai componenti utilizzando file `.content.{ts|js|json}`.
+- **Type safety**: Sfrutta l'integrazione TypeScript per la validazione del contenuto in fase di compilazione.
+- **Ottimizzazione in fase di build**: Utilizza gli strumenti di build di Intlayer per il tree-shaking automatico e l'ottimizzazione del bundle.
+- **Tooling integrato**: Approfitta del routing integrato, degli helper SEO e del supporto dell'editor visuale.
+
+  </Tab>
+</Tabs>
+
+---
+
 ## E il vincitore è…
 
 Non è semplice. Ogni opzione ha dei compromessi. Ecco come la vedo:

package/blog/it/rag_powered_documentation_assistant.md

@@ -57,43 +57,6 @@ Quel ultimo punto è cruciale. Un sistema RAG non si limita a rispondere alle do
 
 Quindi, RAG non è solo uno strumento di supporto. È anche un **motore di scoperta del prodotto**.
 
-## Come funziona la pipeline RAG
-
-![RAG Pipeline](https://github.com/aymericzip/intlayer/blob/main/docs/assets/rag_flow.svg)
-
-Ad alto livello, ecco la ricetta che ho usato:
-
-1.  **Suddivisione della documentazione in chunk** Grandi file Markdown vengono divisi in chunk. La suddivisione permette di fornire come contesto solo le parti rilevanti della documentazione.
-2.  **Generazione degli embeddings** Ogni chunk viene trasformato in un vettore usando l’API di embedding di OpenAI (text-embedding-3-large) o un database vettoriale (Chroma, Qdrant, Pinecone).
-3.  **Indicizzazione e memorizzazione** Gli embeddings vengono memorizzati in un semplice file JSON (per la mia demo), ma in produzione probabilmente useresti un database vettoriale.
-4.  **Recupero (R in RAG)** La query dell’utente viene trasformata in embedding, si calcola la similarità coseno e si recuperano i chunk più pertinenti.
-5.  **Aumento + Generazione (AG in RAG)** Quei chunk vengono inseriti nel prompt per ChatGPT, così il modello risponde con il contesto reale della documentazione.
-6.  **Registrazione delle query per feedback** Ogni query utente viene memorizzata. Questo è prezioso per capire i punti critici, la documentazione mancante o nuove opportunità.
-
-## Passo 1: Lettura della Documentazione
-
-Il primo passo è stato semplice: avevo bisogno di un modo per scansionare una cartella docs/ per tutti i file .md. Usando Node.js e glob, ho recuperato il contenuto di ogni file Markdown in memoria.
-
-Questo mantiene la pipeline flessibile: invece di Markdown, potresti recuperare la documentazione da un database, un CMS o anche un'API.
-
-## Passo 2: Suddividere la Documentazione in Chunk
-
-Perché suddividere in chunk? Perché i modelli linguistici hanno **limiti di contesto**. Fornire loro un intero libro di documentazione non funzionerà.
-
-Quindi l'idea è di spezzare il testo in chunk gestibili (ad esempio 500 token ciascuno) con sovrapposizione (ad esempio 100 token). La sovrapposizione garantisce continuità così da non perdere il significato ai confini dei chunk.
-
-**Esempio:**
-
-- Chunk 1 → “…la vecchia biblioteca che molti avevano dimenticato. Le sue scaffalature imponenti erano piene di libri…”
-- Chunk 2 → “…le scaffalature erano piene di libri di ogni genere immaginabile, ognuno sussurrando storie…”
-
-La sovrapposizione assicura che entrambi i chunk contengano un contesto condiviso, così il recupero rimane coerente.
-
-Questo compromesso (dimensione del chunk vs sovrapposizione) è fondamentale per l’efficienza di RAG:
-
-- Troppo piccolo → si genera rumore.
-- Troppo grande → si satura la dimensione del contesto.
-
 ## Passo 3: Generazione degli Embeddings
 
 Una volta che i documenti sono stati suddivisi in chunk, generiamo gli **embeddings**, vettori ad alta dimensione che rappresentano ogni chunk.
@@ -112,164 +75,6 @@ Ho utilizzato il modello text-embedding-3-large di OpenAI, ma potresti usare qua
 
 Ogni vettore è un’impronta matematica del testo, che permette la ricerca per similarità.
 
-## Passo 4: Indicizzazione e Memorizzazione degli Embeddings
-
-Per evitare di rigenerare gli embeddings più volte, li ho memorizzati in embeddings.json.
-
-In produzione, probabilmente vorresti un database vettoriale come:
-
-- Chroma
-- Qdrant
-- Pinecone
-- FAISS, Weaviate, Milvus, ecc.
-
-I database vettoriali gestiscono indicizzazione, scalabilità e ricerca veloce. Ma per il mio prototipo, un JSON locale ha funzionato bene.
-
-## Passo 5: Recupero con Similarità Coseno
-
-Quando un utente fa una domanda:
-
-1. Genera un embedding per la query.
-2. Confrontalo con tutti gli embedding dei documenti usando la **similarità coseno**.
-3. Conserva solo i primi N chunk più simili.
-
-La similarità coseno misura l'angolo tra due vettori. Una corrispondenza perfetta ottiene un punteggio di **1.0**.
-
-In questo modo, il sistema trova i passaggi del documento più vicini alla query.
-
-## Passo 6: Aggiunta + Generazione
-
-Ora arriva la magia. Prendiamo i chunk migliori e li inseriamo nel **prompt di sistema** per ChatGPT.
-
-Ciò significa che il modello risponde come se quei frammenti facessero parte della conversazione.
-
-Il risultato: risposte accurate e **basate sulla documentazione**.
-
-## Passo 7: Registrazione delle Query degli Utenti
-
-Questa è la superpotenza nascosta.
-
-Ogni domanda posta viene memorizzata. Nel tempo, si costruisce un dataset di:
-
-- Domande più frequenti (ottimo per le FAQ)
-- Domande senza risposta (documentazione mancante o poco chiara)
-- Richieste di funzionalità mascherate da domande (“Si integra con X?”)
-- Casi d’uso emergenti che non avevi previsto
-
-Questo trasforma il tuo assistente RAG in uno **strumento continuo di ricerca utenti**.
-
-## Quanto Costa?
-
-Una comune obiezione al RAG è il costo. In pratica, è sorprendentemente economico:
-
-- Generare embedding per circa 200 documenti richiede circa **5 minuti** e costa **1–2 euro**.
-- La funzione di ricerca nei documenti è completamente gratuita.
-- Per le query, utilizziamo gpt-4o-latest senza la modalità “thinking”. Su Intlayer, registriamo circa **300 query chat al mese**, e la fattura dell’API OpenAI raramente supera i **10$**.
-
-Oltre a questo, puoi includere il costo dell’hosting.
-
-## Dettagli di Implementazione
-
-Stack:
-
-- Monorepo: workspace pnpm
-- Pacchetto Doc: Node.js / TypeScript / OpenAI API
-- Frontend: Next.js / React / Tailwind CSS
-- Backend: route API Node.js / OpenAI API
-
-Il pacchetto `@smart-doc/docs` è un pacchetto TypeScript che gestisce l’elaborazione della documentazione. Quando un file markdown viene aggiunto o modificato, il pacchetto include uno script `build` che ricostruisce la lista della documentazione in ogni lingua, genera gli embeddings e li memorizza in un file `embeddings.json`.
-
-Per il frontend, utilizziamo un’applicazione Next.js che fornisce:
-
-- Rendering da Markdown a HTML
-- Una barra di ricerca per trovare la documentazione rilevante
-- Un'interfaccia chatbot per porre domande sulla documentazione
-
-Per eseguire una ricerca nella documentazione, l'applicazione Next.js include una route API che chiama una funzione nel pacchetto `@smart-doc/docs` per recuperare i frammenti di documentazione corrispondenti alla query. Utilizzando questi frammenti, possiamo restituire una lista di pagine della documentazione rilevanti per la ricerca dell'utente.
-
-Per la funzionalità chatbot, seguiamo lo stesso processo di ricerca ma in aggiunta iniettiamo i frammenti di documentazione recuperati nel prompt inviato a ChatGPT.
-
-Ecco un esempio di prompt inviato a ChatGPT:
-
-Prompt di sistema:
-
-```txt
-Sei un assistente utile che può rispondere a domande sulla documentazione di Intlayer.
-
-Frammenti correlati:
-
------
-docName: "getting-started"
-docChunk: "1/3"
-docUrl: "https://example.com/docs/it/getting-started"
----
-
-# Come iniziare
-
-...
-
------
-docName: "another-doc"
-docChunk: "1/5"
-docUrl: "https://example.com/docs/it/another-doc"
----
-
-# Un altro documento
-
-...
-```
-
-Query utente :
-
-```txt
-Come iniziare?
-```
-
-Usiamo SSE per trasmettere la risposta dalla route API.
-
-Come accennato, utilizziamo gpt-4-turbo senza la modalità "thinking". Le risposte sono pertinenti e la latenza è bassa.
-Abbiamo sperimentato con gpt-5, ma la latenza era troppo alta (a volte fino a 15 secondi per una risposta). Tuttavia, lo rivaluteremo in futuro.
-
-👉 [Prova la demo qui](https://intlayer.org/doc/why) 👉 [Controlla il modello di codice su GitHub](https://github.com/aymericzip/smart_doc_RAG)
-
-## Andare oltre
-
-Questo progetto è una implementazione minima. Ma puoi estenderlo in molti modi:
-
-- Server MCP → la funzione di ricerca nella documentazione verso un server MCP per connettere la documentazione a qualsiasi assistente AI
-
-- Database vettoriali → scalare a milioni di frammenti di documenti
-- LangChain / LlamaIndex → framework pronti all'uso per pipeline RAG
-- Cruscotti di analisi → visualizzare le query degli utenti e i punti critici
-- Recupero multi-sorgente → estrarre non solo documenti, ma anche voci di database, post di blog, ticket, ecc.
-- Prompting migliorato → riordinamento, filtraggio e ricerca ibrida (parola chiave + semantica)
-
-## Limitazioni che abbiamo incontrato
-
-- La suddivisione in frammenti e la sovrapposizione sono empiriche. Il giusto equilibrio (dimensione del frammento, percentuale di sovrapposizione, numero di frammenti recuperati) richiede iterazione e test.
-- Gli embeddings non vengono rigenerati automaticamente quando i documenti cambiano. Il nostro sistema resetta gli embeddings per un file solo se il numero di frammenti differisce da quello memorizzato.
-- In questo prototipo, gli embeddings sono memorizzati in JSON. Questo funziona per le demo ma inquina Git. In produzione, è meglio utilizzare un database o un archivio vettoriale dedicato.
-
-## Perché Questo È Importante Oltre la Documentazione
-
-La parte interessante non è solo il chatbot. È il **ciclo di feedback**.
-
-Con RAG, non ti limiti a rispondere:
-
-- Impari cosa confonde gli utenti.
-- Scopri quali funzionalità si aspettano.
-- Adatti la tua strategia di prodotto basandoti sulle query reali.
-
-**Esempio:**
-
-Immagina di lanciare una nuova funzionalità e vedere immediatamente:
-
-- Il 50% delle domande riguarda lo stesso passaggio di configurazione poco chiaro
-- Gli utenti chiedono ripetutamente un’integrazione che ancora non supporti
-- Le persone cercano termini che rivelano un nuovo caso d’uso
-
-Questa è **intelligenza di prodotto** direttamente dai tuoi utenti.
-
 ## Conclusione
 
 RAG è uno dei modi più semplici e potenti per rendere pratici i LLM. Combinando **recupero + generazione**, puoi trasformare documenti statici in un **assistente intelligente** e, allo stesso tempo, ottenere un flusso continuo di approfondimenti sul prodotto.

package/blog/it/react-i18next_vs_react-intl_vs_intlayer.md

@@ -141,6 +141,14 @@ Valutiamo:
 
 ---
 
+## Interoperabilità con `react-intl` e `react-i18next`
+
+`intlayer` può aiutarti anche a gestire i tuoi namespace `react-intl` e `react-i18next`.
+
+Utilizzando `intlayer`, puoi dichiarare i tuoi contenuti nel formato della tua libreria i18n preferita, e intlayer genererà i tuoi namespace nella posizione di tua scelta (esempio: `/messages/{{locale}}/{{namespace}}.json`).
+
+---
+
 ## Note pratiche per la migrazione (react-intl / react-i18next → Intlayer)
 
 - **Migra in modo incrementale**: Inizia con una funzionalità o una rotta; mantieni i cataloghi legacy in parallelo durante la transizione.