diff --git a/common/data_source/rdbms_connector.py b/common/data_source/rdbms_connector.py
index 9811d2064d..1e269c0678 100644
--- a/common/data_source/rdbms_connector.py
+++ b/common/data_source/rdbms_connector.py
@@ -1,9 +1,10 @@
-"""RDBMS (MySQL/PostgreSQL) data source connector for importing data from relational databases."""
+"""RDBMS (MySQL/PostgreSQL/MSSQL) data source connector for importing data from relational databases."""
 
 import copy
 import hashlib
 import json
 import logging
+import re
 from datetime import datetime, timezone
 from enum import Enum
 from typing import Any, Dict, Generator, Optional, Union
@@ -26,11 +27,12 @@ class DatabaseType(str, Enum):
     """Supported database types."""
     MYSQL = "mysql"
     POSTGRESQL = "postgresql"
+    MSSQL = "mssql"
 
 
 class RDBMSConnector(LoadConnector, PollConnector, SlimConnectorWithPermSync):
     """
-    Import rows from MySQL or PostgreSQL into documents.
+    Import rows from MySQL, PostgreSQL or Microsoft SQL Server into documents.
 
     The flow is:
     1. Connect to the configured database.
@@ -58,7 +60,7 @@ class RDBMSConnector(LoadConnector, PollConnector, SlimConnectorWithPermSync):
         Initialize the RDBMS connector.
         
         Args:
-            db_type: Database type ('mysql' or 'postgresql')
+            db_type: Database type ('mysql', 'postgresql', or 'mssql')
             host: Database host
             port: Database port
             database: Database name
@@ -73,8 +75,10 @@ class RDBMSConnector(LoadConnector, PollConnector, SlimConnectorWithPermSync):
         self.host = host.strip()
         self.port = port
         self.database = database.strip()
-        self.query = query.strip()
-        self.content_columns = [c.strip() for c in content_columns.split(",") if c.strip()]
+        self.query = self._sanitize_query(query)
+        # content_columns is optional: when empty, every column returned by the
+        # query is used as document content (see _content_columns_for_row).
+        self.content_columns = [c.strip() for c in (content_columns or "").split(",") if c.strip()]
         self.metadata_columns = [c.strip() for c in (metadata_columns or "").split(",") if c.strip()]
         self.id_column = id_column.strip() if id_column else None
         self.timestamp_column = timestamp_column.strip() if timestamp_column else None
@@ -86,6 +90,44 @@ class RDBMSConnector(LoadConnector, PollConnector, SlimConnectorWithPermSync):
         self._sync_config: Dict[str, Any] | None = None
         self._pending_sync_cursor_value: Any = None
 
+    # Language labels that may leak in when a query is pasted from a
+    # markdown ```sql code fence.
+    _FENCE_LANGUAGES = {"sql", "tsql", "t-sql", "mssql", "mysql", "postgresql", "psql"}
+
+    @classmethod
+    def _sanitize_query(cls, raw: Optional[str]) -> str:
+        """Clean a user-supplied SQL query.
+
+        Tolerates queries pasted straight from a markdown code block, e.g.
+        a surrounding ``` ... ``` fence or a leading bare ``sql`` language
+        label on its own line.
+        """
+        query = (raw or "").strip()
+        if not query:
+            return ""
+        # Strip a surrounding ``` ... ``` markdown fence.
+        if query.startswith("```"):
+            query = query[3:]
+            if query.endswith("```"):
+                query = query[:-3]
+            query = query.strip()
+        # Drop a leading line that is only a code-fence language label.
+        head, _, tail = query.partition("\n")
+        if tail and head.strip().lower() in cls._FENCE_LANGUAGES:
+            query = tail.strip()
+        return query
+
+    def _content_columns_for_row(self, row_dict: Dict[str, Any]) -> list[str]:
+        """Resolve which columns make up the document content for a row.
+
+        When no content columns are configured, every column returned by the
+        query is used, excluding the structural id/timestamp columns.
+        """
+        if self.content_columns:
+            return self.content_columns
+        excluded = {self.id_column, self.timestamp_column}
+        return [col for col in row_dict.keys() if col not in excluded]
+
     def load_credentials(self, credentials: Dict[str, Any]) -> Dict[str, Any] | None:
         """Load database credentials."""
         logging.debug(f"Loading credentials for {self.db_type} database: {self.database}")
@@ -142,7 +184,25 @@ class RDBMSConnector(LoadConnector, PollConnector, SlimConnectorWithPermSync):
                 )
             except Exception as e:
                 raise ConnectorValidationError(f"Failed to connect to PostgreSQL: {e}")
-        
+        elif self.db_type == DatabaseType.MSSQL:
+            try:
+                import pymssql
+            except ImportError:
+                raise ConnectorValidationError(
+                    "pymssql not installed. Please install pymssql."
+                )
+            try:
+                self._connection = pymssql.connect(
+                    server=self.host,
+                    port=self.port,
+                    user=username,
+                    password=password,
+                    database=self.database,
+                    charset="UTF-8",
+                )
+            except Exception as e:
+                raise ConnectorValidationError(f"Failed to connect to SQL Server: {e}")
+
         return self._connection
 
     def _close_connection(self):
@@ -162,6 +222,11 @@ class RDBMSConnector(LoadConnector, PollConnector, SlimConnectorWithPermSync):
         try:
             if self.db_type == DatabaseType.MYSQL:
                 cursor.execute("SHOW TABLES")
+            elif self.db_type == DatabaseType.MSSQL:
+                cursor.execute(
+                    "SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES "
+                    "WHERE TABLE_TYPE = 'BASE TABLE'"
+                )
             else:
                 cursor.execute(
                     "SELECT table_name FROM information_schema.tables "
@@ -174,22 +239,51 @@ class RDBMSConnector(LoadConnector, PollConnector, SlimConnectorWithPermSync):
 
 
     def _get_base_queries(self) -> list[str]:
+        """Return the list of base SQL queries to execute.
+
+        When a custom query is configured, returns it as a single-element list.
+        Otherwise returns a ``SELECT * FROM <table>`` query for every table in
+        the database.
+        """
         if self.query:
             return [self.query.rstrip(";")]
         return [f"SELECT * FROM {table}" for table in self._get_tables()]
 
 
+    @staticmethod
+    def _strip_trailing_order_by(query: str) -> str:
+        """Remove a trailing top-level ORDER BY clause.
+
+        SQL Server rejects ORDER BY inside a derived table
+        ("SELECT ... FROM (<query>) AS src"), and row order is irrelevant for
+        ingestion. A parenthesised ORDER BY (e.g. an OVER(...) window clause)
+        is left untouched because it is not at depth 0.
+        """
+        cleaned = query.rstrip().rstrip(";").rstrip()
+        for match in reversed(list(re.finditer(r"\border\s+by\b", cleaned, re.IGNORECASE))):
+            prefix = cleaned[: match.start()]
+            if prefix.count("(") == prefix.count(")"):
+                return prefix.rstrip()
+        return cleaned
+
     def _wrap_query(self, base_query: str, select_clause: str = "*") -> str:
-        return f"SELECT {select_clause} FROM ({base_query}) AS ragflow_src"
+        """Wrap *base_query* as a derived table so WHERE / SELECT clauses can be appended.
+
+        Strips any trailing top-level ORDER BY before wrapping because SQL Server
+        rejects ORDER BY inside a derived-table subquery.
+        """
+        inner = self._strip_trailing_order_by(base_query)
+        return f"SELECT {select_clause} FROM ({inner}) AS ragflow_src"
 
 
     @staticmethod
     def serialize_cursor_value(value: Any) -> Any:
-        # Example:
-        # - int cursor 42 is stored as 42
-        # - datetime cursor 2026-05-07T12:34:56+00:00 is stored as
-        #   {"__ragflow_rdbms_cursor_type__": "datetime", "value": "..."}
-        # Only datetime needs wrapping because connector config is JSON.
+        """Serialize a cursor value to a JSON-safe representation.
+
+        Primitive types (int, float, str) are returned as-is. ``datetime``
+        objects are wrapped in a typed dict so they survive a JSON round-trip:
+        ``{"__ragflow_rdbms_cursor_type__": "datetime", "value": "<isoformat>"}``.
+        """
         if isinstance(value, datetime):
             return {
                 "__ragflow_rdbms_cursor_type__": "datetime",
@@ -200,8 +294,11 @@ class RDBMSConnector(LoadConnector, PollConnector, SlimConnectorWithPermSync):
 
     @staticmethod
     def deserialize_cursor_value(value: Any) -> Any:
-        # Reverse the datetime wrapper above.
-        # Non-datetime cursors such as int/str/float are returned as-is.
+        """Deserialize a cursor value produced by :meth:`serialize_cursor_value`.
+
+        Recognises the ``__ragflow_rdbms_cursor_type__`` wrapper and converts it
+        back to a ``datetime``. Any other value is returned unchanged.
+        """
         if (
             isinstance(value, dict)
             and value.get("__ragflow_rdbms_cursor_type__") == "datetime"
@@ -211,6 +308,12 @@ class RDBMSConnector(LoadConnector, PollConnector, SlimConnectorWithPermSync):
 
 
     def _format_sql_value(self, value: Any) -> str:
+        """Format a Python value as a SQL literal suitable for embedding in a WHERE clause.
+
+        Handles ``datetime``, ``bool``, numeric, and string types with
+        database-specific formatting where needed (e.g. MySQL datetime format vs.
+        ISO-8601 for PostgreSQL/MSSQL, boolean literals for PostgreSQL).
+        """
         if isinstance(value, datetime):
             if value.tzinfo is None:
                 value = value.replace(tzinfo=timezone.utc)
@@ -238,8 +341,20 @@ class RDBMSConnector(LoadConnector, PollConnector, SlimConnectorWithPermSync):
         start: Any = None,
         end: Any = None,
     ) -> str:
+        """Build a query that filters rows by the configured timestamp column.
+
+        When no timestamp column is set, or neither bound is provided, the base
+        query is returned verbatim (no derived-table wrapping) so that trailing
+        clauses such as ORDER BY remain valid for all database backends.
+        Otherwise the base query is wrapped as a derived table and a WHERE clause
+        with ``> start`` and/or ``<= end`` conditions is appended.
+        """
         if not self.timestamp_column or (start is None and end is None):
-            return self._wrap_query(base_query)
+            # No incremental filter to apply: run the user's query verbatim so
+            # trailing clauses such as ORDER BY stay valid. Wrapping it as a
+            # derived table ("SELECT * FROM (... ORDER BY ...) AS src") is
+            # rejected by SQL Server.
+            return base_query
 
         conditions = []
         if start is not None:
@@ -258,6 +373,7 @@ class RDBMSConnector(LoadConnector, PollConnector, SlimConnectorWithPermSync):
 
 
     def _build_max_timestamp_query(self, base_query: str) -> str:
+        """Build a query that returns the maximum value of the timestamp column."""
         return (
             f"SELECT MAX(ragflow_src.{self.timestamp_column}) "
             f"FROM ({base_query}) AS ragflow_src"
@@ -265,14 +381,25 @@ class RDBMSConnector(LoadConnector, PollConnector, SlimConnectorWithPermSync):
 
 
     def _build_slim_query(self, base_query: str) -> str:
+        """Build a lightweight query that fetches only the columns needed to identify documents.
+
+        Selects the id column when configured, falls back to the content columns,
+        or selects every column when neither is set (the whole row is hashed to
+        derive the document id).
+        """
         columns = [self.id_column] if self.id_column else self.content_columns
+        if not columns:
+            # No id column and no explicit content columns: the slim snapshot
+            # hashes the whole row, so it needs every column.
+            return self._wrap_query(base_query, "*")
         select_clause = ", ".join(f"ragflow_src.{column}" for column in columns)
         return self._wrap_query(base_query, select_clause)
 
 
     def _build_content(self, row_dict: Dict[str, Any]) -> str:
+        """Build the document content string from the resolved content columns of a row."""
         content_parts = []
-        for col in self.content_columns:
+        for col in self._content_columns_for_row(row_dict):
             if col not in row_dict or row_dict[col] is None:
                 continue
             value = row_dict[col]
@@ -283,6 +410,11 @@ class RDBMSConnector(LoadConnector, PollConnector, SlimConnectorWithPermSync):
 
 
     def _build_document_id_from_row(self, row_dict: Dict[str, Any]) -> str:
+        """Derive a stable document id from a database row.
+
+        Uses ``<db_type>:<database>:<id_column_value>`` when an id column is
+        configured, otherwise falls back to an MD5 hash of the document content.
+        """
         if self.id_column and self.id_column in row_dict and row_dict[self.id_column] is not None:
             return f"{self.db_type}:{self.database}:{row_dict[self.id_column]}"
         content = self._build_content(row_dict)
@@ -296,7 +428,9 @@ class RDBMSConnector(LoadConnector, PollConnector, SlimConnectorWithPermSync):
         column_names: list[str],
     ) -> Document:
         """Convert a database row to a Document."""
-        row_dict = dict(zip(column_names, row)) if isinstance(row, (list, tuple)) else row
+        # pyodbc.Row (SQL Server) is neither a tuple nor a dict and does not
+        # support string-keyed lookup, so always normalise to a plain dict.
+        row_dict = row if isinstance(row, dict) else dict(zip(column_names, row))
         content = self._build_content(row_dict)
         metadata = {}
         for col in self.metadata_columns:
@@ -320,7 +454,8 @@ class RDBMSConnector(LoadConnector, PollConnector, SlimConnectorWithPermSync):
                 else:
                     doc_updated_at = ts_value.astimezone(timezone.utc)
 
-        first_content_col = self.content_columns[0] if self.content_columns else "record"
+        resolved_content_columns = self._content_columns_for_row(row_dict)
+        first_content_col = resolved_content_columns[0] if resolved_content_columns else "record"
         semantic_id = (
             str(row_dict.get(first_content_col, "database_record"))
             .replace("\n", " ")
@@ -382,6 +517,11 @@ class RDBMSConnector(LoadConnector, PollConnector, SlimConnectorWithPermSync):
         self,
         query: str,
     ) -> Generator[list[SlimDocument], None, None]:
+        """Yield batches of :class:`SlimDocument` objects from *query*.
+
+        Only the document id is populated; no content is fetched. Used during
+        permission sync to detect and remove stale documents.
+        """
         connection = self._get_connection()
         cursor = connection.cursor()
 
@@ -392,7 +532,7 @@ class RDBMSConnector(LoadConnector, PollConnector, SlimConnectorWithPermSync):
 
             batch: list[SlimDocument] = []
             for row in cursor:
-                row_dict = dict(zip(column_names, row)) if isinstance(row, (list, tuple)) else row
+                row_dict = row if isinstance(row, dict) else dict(zip(column_names, row))
                 batch.append(SlimDocument(id=self._build_document_id_from_row(row_dict)))
                 if len(batch) >= self.batch_size:
                     yield batch
@@ -409,6 +549,12 @@ class RDBMSConnector(LoadConnector, PollConnector, SlimConnectorWithPermSync):
 
 
     def get_max_cursor_value(self) -> Any:
+        """Return the maximum value of the timestamp column across all base queries.
+
+        Returns ``None`` when no timestamp column is configured or the result set
+        is empty.  Used to snapshot the upper bound of the sync window before
+        fetching documents.
+        """
         if not self.timestamp_column:
             return None
 
@@ -460,6 +606,7 @@ class RDBMSConnector(LoadConnector, PollConnector, SlimConnectorWithPermSync):
         self,
         callback: Any = None,
     ) -> Generator[list[SlimDocument], None, None]:
+        """Yield slim snapshots of all current documents for stale-document reconciliation."""
         del callback
 
         base_queries = self._get_base_queries()
@@ -475,6 +622,12 @@ class RDBMSConnector(LoadConnector, PollConnector, SlimConnectorWithPermSync):
             self._close_connection()
 
     def prepare_sync_state(self, connector_id: str, config: Dict[str, Any]) -> None:
+        """Snapshot the current maximum cursor value before documents are fetched.
+
+        Must be called before :meth:`load_from_cursor_range` so the upper bound
+        of the sync window is captured atomically and can be persisted afterwards
+        via :meth:`persist_sync_state`.
+        """
         self._sync_connector_id = connector_id
         self._sync_config = copy.deepcopy(config)
         if not self.timestamp_column:
@@ -484,12 +637,18 @@ class RDBMSConnector(LoadConnector, PollConnector, SlimConnectorWithPermSync):
 
 
     def get_saved_sync_cursor_value(self) -> Any:
+        """Return the cursor value that was persisted at the end of the previous sync run."""
         if self._sync_config is None:
             return None
         return self.deserialize_cursor_value(self._sync_config.get("sync_cursor_value"))
 
 
     def persist_sync_state(self) -> None:
+        """Write the pending cursor value back to the connector config in the database.
+
+        No-op when no timestamp column is configured or :meth:`prepare_sync_state`
+        was not called.
+        """
         if not self.timestamp_column or self._sync_connector_id is None or self._sync_config is None:
             return
 
@@ -508,6 +667,11 @@ class RDBMSConnector(LoadConnector, PollConnector, SlimConnectorWithPermSync):
         start_value: Any = None,
         end_value: Any = None,
     ) -> Generator[list[Document], None, None]:
+        """Yield documents whose timestamp column falls in ``(start_value, end_value]``.
+
+        Returns an empty iterator when *end_value* is ``None`` or the range is
+        empty (``end_value <= start_value``).
+        """
         if end_value is None:
             self._close_connection()
             return iter(())
@@ -540,12 +704,10 @@ class RDBMSConnector(LoadConnector, PollConnector, SlimConnectorWithPermSync):
         
         if not self.database:
             raise ConnectorValidationError("Database name is required.")
-        
-        if not self.content_columns:
-            raise ConnectorValidationError(
-                "At least one content column must be specified."
-            )
-        
+
+        # content_columns is intentionally optional: an empty value means
+        # "use every column returned by the query" (see _content_columns_for_row).
+
         try:
             connection = self._get_connection()
             cursor = connection.cursor()
diff --git a/web/src/locales/it.ts b/web/src/locales/it.ts
index 1856fefbae..7192c506b5 100644
--- a/web/src/locales/it.ts
+++ b/web/src/locales/it.ts
@@ -4,7 +4,7 @@ export default {
       confirm: 'Conferma',
       back: 'Indietro',
       noResults: 'Nessun risultato trovato',
-      selectPlaceholder: 'seleziona valore',
+      selectPlaceholder: 'Seleziona valore',
       selectAll: 'Seleziona tutto',
       delete: 'Elimina',
       deleteModalTitle: 'Sei sicuro di voler eliminare?',
@@ -18,6 +18,7 @@ export default {
       name: 'Nome',
       save: 'Salva',
       namePlaceholder: 'Inserisci il nome',
+      descriptionPlaceholder: 'Inserisci la descrizione',
       next: 'Avanti',
       create: 'Crea',
       edit: 'Modifica',
@@ -27,20 +28,24 @@ export default {
       chinese: 'Cinese semplificato',
       traditionalChinese: 'Cinese tradizionale',
       russian: 'Russo',
-      bulgarian: 'Bulgaro',
-      arabic: 'Arabo',
-      italian: 'Italiano',
+      indonesian: 'Indonesiano',
+      indonesia: 'Indonesiano',
+      spanish: 'Spagnolo',
+      vietnamese: 'Vietnamita',
+      japanese: 'Giapponese',
       german: 'Tedesco',
       french: 'Francese',
-      spanish: 'Spagnolo',
-      japanese: 'Giapponese',
-      vietnamese: 'Vietnamita',
-      indonesian: 'Indonesiano',
+      italian: 'Italiano',
+      bulgarian: 'Bulgaro',
+      arabic: 'Arabo',
+      turkish: 'Turco',
       language: 'Lingua',
       languageMessage: 'Inserisci la tua lingua!',
       languagePlaceholder: 'Seleziona la tua lingua',
       copy: 'Copia',
       copied: 'Copiato',
+      viewMore: 'Mostra di più',
+      viewLess: 'Mostra di meno',
       comingSoon: 'Prossimamente',
       download: 'Scarica',
       close: 'Chiudi',
@@ -57,6 +62,7 @@ export default {
       openInNewTab: 'Chat in una nuova scheda',
       previousPage: 'Precedente',
       nextPage: 'Successivo',
+      previous: 'Precedente',
       add: 'Aggiungi',
       remove: 'Rimuovi',
       search: 'Cerca',
@@ -71,6 +77,8 @@ export default {
         tokenPlaceholder: 'es. eyJhbGciOiJIUzI1Ni...',
       },
       selected: 'Selezionato',
+      seeAll: 'Vedi tutto',
+      bulkOperate: 'Operazione multipla',
     },
     login: {
       loginTitle: 'Accedi al tuo account',
@@ -93,8 +101,9 @@ export default {
       title: 'Un motore RAG leader per il contesto LLM',
       start: 'Iniziamo',
       description:
-        'Registrati gratuitamente per esplorare la migliore tecnologia RAG. Crea basi di conoscenza e IA per potenziare il tuo business.',
+        'Registrati gratuitamente per esplorare la migliore tecnologia RAG. Crea dataset e IA per potenziare il tuo business.',
       review: 'da oltre 500 recensioni',
+      seeAll: 'Vedi tutto',
     },
     header: {
       knowledgeBase: 'Dataset',
@@ -105,13 +114,190 @@ export default {
       setting: 'Impostazioni utente',
       logout: 'Esci',
       fileManager: 'File',
+      skills: 'Skill',
       flow: 'Agente',
       search: 'Cerca',
       welcome: 'Benvenuto su',
       dataset: 'Dataset',
-      Memories: 'Memoria',
+      memories: 'Memoria',
     },
-    memory: {
+    skills: {
+      title: 'Skill',
+      selectSpace: 'Seleziona uno spazio skill per iniziare',
+      spacePlaceholder: 'Inserisci il nome dello spazio',
+      createSpace: 'Crea spazio skill',
+      createSpaceTitle: 'Crea nuovo spazio skill',
+      createSpaceDescription:
+        'Crea un nuovo spazio per organizzare e gestire le tue skill.',
+      spaceName: 'Nome spazio',
+      spaceNamePlaceholder: 'es. il-mio-spazio',
+      spaceNameRequired: 'Inserisci il nome dello spazio',
+      noSpaces: 'Nessuno spazio skill ancora. Crea il tuo primo!',
+      enterSpace: 'Entra',
+      spaceCreated: 'Spazio skill creato con successo',
+      spaceDeleted: 'Spazio skill eliminato con successo',
+      fetchError: 'Impossibile recuperare le skill',
+      deleteSpaceTitle: 'Elimina spazio skill',
+      deleteSpaceDescription:
+        'Sei sicuro di voler eliminare questo spazio skill? Questa azione non può essere annullata e tutte le skill in questo spazio saranno eliminate permanentemente.',
+      deleteSpaceName: 'Nome spazio',
+      uploadSuccess: 'Skill caricata con successo',
+      uploadError: 'Impossibile caricare la skill',
+      deleteSuccess: 'Skill eliminata con successo',
+      deleteError: 'Impossibile eliminare la skill',
+      skillExists:
+        'Una skill con questo nome esiste già. Eliminala prima o usa un nome diverso.',
+      uploadSkill: 'Carica skill',
+      searchPlaceholder: 'Cerca skill...',
+      noSkills: 'Nessuna skill ancora. Carica la tua prima skill.',
+      noSearchResults: 'Nessuna skill corrisponde alla tua ricerca',
+      filesCount: '{{count}} file',
+      foldersCount: '{{count}} cartelle',
+      pageInfo: 'Pagina {{current}} di {{total}}',
+      totalSkills: '{{total}} skill totali',
+      backToSkills: 'Torna alle skill',
+      selectFileToView: 'Seleziona un file da visualizzare',
+      skillName: 'Nome skill',
+      skillNamePlaceholder: 'es. la-mia-skill',
+      skillNameHelp: 'Sono ammessi solo lettere, numeri, trattini e underscore',
+      source: 'Fonte',
+      version: 'Versione',
+      skillVersion: 'Versione',
+      skillVersionPlaceholder: 'es. 1.0.0',
+      versionFormatHelp: 'La versione deve essere in formato semver (es. 1.0.0)',
+      versionRequired: 'La versione è richiesta',
+      selectFilesOrFolder: 'Seleziona file o cartella',
+      uploadDescription:
+        'Carica i file della skill. Puoi trascinare e rilasciare i file o selezionare una cartella.',
+      selectFolder: 'Seleziona cartella',
+      dragFilesHint: 'o trascina i file qui sotto',
+      dragFilesTitle: 'Trascina qui la cartella skill',
+      dragFilesDescription:
+        'Trascina e rilascia qui una cartella skill, oppure usa il pulsante "Seleziona cartella" qui sotto.',
+      filesSelected: '{{count}} file selezionati',
+      uploading: 'Caricamento...',
+      files: 'File',
+      noFiles: 'Nessun file',
+      versionHistory: 'Cronologia versioni',
+      selectVersion: 'Seleziona versione da visualizzare',
+      latest: 'Ultima',
+      metadata: {
+        basic: 'Informazioni base',
+        emoji: 'Emoji',
+        skillKey: 'Chiave skill',
+        always: 'Sempre attiva',
+        primaryEnv: 'Variabile ambiente primaria',
+        requires: 'Requisiti',
+        requiredBins: 'Binari richiesti',
+        requiredEnv: 'Variabili ambiente richieste',
+        anyBins: 'Almeno uno richiesto',
+        install: 'Dipendenze',
+        links: 'Link',
+        homepage: 'Homepage',
+        repository: 'Repository',
+        documentation: 'Documentazione',
+      },
+      validation: {
+        missing_skill_md:
+          'Skill non valida: SKILL.md non trovato. Assicurati che la directory della skill contenga un file SKILL.md valido.',
+        invalid_frontmatter:
+          'Skill non valida: SKILL.md deve avere un frontmatter valido (inizia e finisce con ---).',
+        missing_name:
+          'Skill non valida: il frontmatter di SKILL.md deve includere un campo "name".',
+        invalid_name_format:
+          'Skill non valida: "name" deve essere minuscolo e URL-safe (solo lettere, numeri, trattini).',
+        invalid_version:
+          'Skill non valida: "version" deve essere un semver valido (es. 1.0.0).',
+        invalid_metadata: 'Skill non valida: i metadati contengono campi non validi.',
+        invalid_file_type: 'Skill non valida: sono ammessi solo file basati su testo.',
+        invalid_path: 'Skill non valida: il percorso del file contiene caratteri non validi.',
+        file_too_large:
+          'Skill non valida: la dimensione del singolo file supera il limite di 5MB.',
+        total_size_exceeded:
+          'Skill non valida: la dimensione totale del bundle supera il limite di 50MB.',
+        no_files: 'Nessun file selezionato. Seleziona una cartella skill.',
+        noValidFiles: 'Nessun file valido trovato. Controlla la tua selezione.',
+        junkFilesFound:
+          'Rilevati file temporanei (es. .DS_Store). Rimuovili prima di caricare.',
+        read_failed: 'Skill non valida: impossibile leggere il file SKILL.md.',
+        invalid: 'Formato skill non valido.',
+        valid: 'Formato skill valido. Pronto per il caricamento.',
+        versionExists:
+          'Questa versione esiste già. Usa un numero di versione diverso.',
+        error: 'Validazione fallita',
+      },
+      parsedMetadata: 'Analizzato da SKILL.md:',
+      addSkill: 'Aggiungi skill',
+      upload: 'Carica',
+      importFromGit: 'Importa da Git',
+      gitPlatform: 'Piattaforma',
+      repoUrl: 'URL repository',
+      repoUrlHelp: 'Supporta URL repository con percorso opzionale',
+      accessToken: 'Token di accesso',
+      githubTokenHelp:
+        'Per repository privati o limiti di frequenza più alti (5000 richieste/ora)',
+      giteeTokenHelp: 'Per repository privati o limiti di frequenza più alti (2000 richieste/ora)',
+      rateLimitInfo: 'Info limite di frequenza',
+      githubRateLimit:
+        'Repository pubblici: 60 richieste/ora per IP. Usa il token per 5000 richieste/ora.',
+      giteeRateLimit:
+        'Repository pubblici: 1000 richieste/ora per IP. Usa il token per 2000 richieste/ora.',
+      import: 'Importa',
+      importing: 'Importazione...',
+      configureSearch: 'Configura ricerca',
+    },
+    skillSearch: {
+      configTitle: 'Configurazione ricerca skill',
+      configDesc: 'Configura come le skill vengono indicizzate e cercate',
+      embeddingModel: 'Modello di embedding',
+      embeddingModelPlaceholder: 'Seleziona un modello di embedding',
+      vectorSimilarityWeight: 'Peso similarità vettoriale',
+      similarityThreshold: 'Soglia di similarità',
+      topK: 'Top K risultati',
+      indexFields: 'Campi indice',
+      indexFieldsDesc: 'Seleziona quali campi includere nell\'indice di ricerca',
+      fieldName: 'Nome',
+      fieldNameDesc: 'Nome skill',
+      fieldTags: 'Tag',
+      fieldTagsDesc: 'Tag skill',
+      fieldDescription: 'Descrizione',
+      fieldDescriptionDesc: 'Descrizione skill',
+      fieldContent: 'Contenuto',
+      fieldContentDesc: 'Contenuto skill (es. README)',
+      weight: 'Peso',
+      pureVector: 'Solo vettore',
+      hybrid: 'Ibrido',
+      keyword: 'Parola chiave',
+      vector: 'Vettore',
+      keywordOnly: 'Solo parola chiave',
+      balanced: 'Bilanciato',
+      vectorOnly: 'Solo vettore',
+      reindex: 'Reindicizza tutto',
+      reindexing: 'Reindicizzazione...',
+      reindexSuccess: 'Reindicizzazione riuscita',
+      pleaseSelectEmbeddingModel: 'Seleziona un modello di embedding',
+      saveSuccess: 'Salvato con successo',
+      saveError: 'Salvataggio fallito',
+      semanticSearchPlaceholder: 'Cerca skill per significato...',
+      switchToSemantic: 'Passa alla ricerca semantica',
+      switchToLocal: 'Passa alla ricerca locale',
+    },
+    memories: {
+      llmTooltip:
+        'Analizza il contenuto della conversazione, estrae le informazioni chiave e genera riepiloghi di memoria strutturati.',
+      embeddingModelTooltip:
+        'Converte il testo in vettori numerici per la ricerca di similarità di significato e il recupero della memoria.',
+      embeddingModelError:
+        'Il tipo di memoria è richiesto e "raw" non può essere eliminato.',
+      memoryTypeTooltip: `Raw: il contenuto grezzo del dialogo tra l'utente e l'agente (richiesto di default).
+Semantic Memory: conoscenza generale e fatti sull'utente e sul mondo.
+Episodic Memory: registri con marcatura temporale di eventi ed esperienze specifiche.
+Procedural Memory: skill apprese, abitudini e procedure automatizzate.`,
+      raw: 'raw',
+      semantic: 'semantic',
+      episodic: 'episodic',
+      procedural: 'procedural',
+      editName: 'Modifica nome',
       memory: 'Memoria',
       createMemory: 'Crea memoria',
       name: 'Nome',
@@ -120,9 +306,30 @@ export default {
       embeddingModel: 'Modello di embedding',
       selectModel: 'Seleziona modello',
       llm: 'LLM',
+      delMemoryWarn: `Dopo l'eliminazione, tutti i messaggi in questa memoria saranno eliminati e non potranno essere recuperati dagli agenti.`,
     },
-    memoryDetail: {
+    memory: {
+      taskLogDialog: {
+        title: 'Memoria',
+        startTime: 'Ora di inizio',
+        status: 'Stato',
+        details: 'Dettagli',
+
+        success: 'Successo',
+        running: 'In esecuzione',
+        failed: 'Fallito',
+      },
+
       messages: {
+        forget: 'Dimentica',
+        forgetMessageTip: 'Sei sicuro di voler dimenticare?',
+        messageDescription:
+          'L\'estrazione della memoria è configurata con i prompt e la temperatura dalle impostazioni avanzate.',
+        copied: 'Copiato!',
+        contentEmbed: 'Embedding contenuto',
+        content: 'Contenuto',
+        delMessageWarn: `Dopo aver dimenticato, questo messaggio non sarà recuperato dagli agenti.`,
+        forgetMessage: 'Dimentica messaggio',
         sessionId: 'ID Sessione',
         agent: 'Agente',
         type: 'Tipo',
@@ -132,18 +339,99 @@ export default {
         enable: 'Abilita',
         action: 'Azione',
       },
+      config: {
+        descriptionPlaceholder: 'Descrivi la tua memoria',
+        memorySizeTooltip: `Considera il contenuto di ogni messaggio + il suo vettore di embedding (≈ Contenuto + Dimensioni × 8 Byte).
+Esempio: un messaggio di 1 KB con embedding a 1024 dimensioni usa ~9 KB. Il limite predefinito di 5 MB contiene ~500 messaggi di questo tipo.`,
+        avatar: 'Avatar',
+        description: 'Descrizione',
+        memorySize: 'Dimensione memoria',
+        advancedSettings: 'Impostazioni avanzate',
+        permission: 'Permesso',
+        onlyMe: 'Solo io',
+        team: 'Team',
+        storageType: 'Tipo di archiviazione',
+        storageTypePlaceholder: 'Seleziona il tipo di archiviazione',
+        forgetPolicy: 'Politica di oblio',
+        temperature: 'Temperatura',
+        systemPrompt: 'Prompt di sistema',
+        systemPromptPlaceholder: 'Inserisci il prompt di sistema',
+        userPrompt: 'Prompt utente',
+        userPromptPlaceholder: 'Inserisci il prompt utente',
+      },
+      sideBar: {
+        messages: 'Messaggi',
+        configuration: 'Configurazione',
+      },
     },
     knowledgeList: {
       welcome: 'Bentornato',
-      description: 'Quali basi di conoscenza userai oggi?',
-      createKnowledgeBase: 'Crea Dataset',
+      description: 'Quali dataset userai oggi?',
+      createKnowledgeBase: 'Crea dataset',
       name: 'Nome',
       namePlaceholder: 'Inserisci il nome.',
       doc: 'Documenti',
       searchKnowledgePlaceholder: 'Cerca',
       noMoreData: `È tutto. Niente altro.`,
+      parserRequired: 'Il metodo di chunking è richiesto',
+      dataFlowRequired: 'Il flusso dati è richiesto',
     },
     knowledgeDetails: {
+      metadata: {
+        fields: 'campi',
+        selectFiles: 'Selezionati {{count}} file',
+        type: 'Tipo',
+        fieldNameInvalid: 'Il nome del campo può contenere solo lettere o underscore.',
+        builtIn: 'Integrato',
+        generation: 'Generazione',
+        toMetadataSetting: 'Impostazioni generazione',
+        toMetadataSettingTip: 'Imposta i metadati automatici nella Configurazione.',
+        descriptionTip:
+          'Fornisci descrizioni o esempi per guidare l\'LLM nell\'estrazione dei valori per questo campo. Se lasciato vuoto, si baserà sul nome del campo.',
+        restrictDefinedValuesTip:
+          'Modalità Enum: limita l\'estrazione dell\'LLM ai soli valori preimpostati. Definisci i valori qui sotto.',
+        valueExists:
+          'Il valore esiste già. Conferma per unire i duplicati e combinare tutti i file associati.',
+        fieldNameExists:
+          'Il nome del campo esiste già. Conferma per unire i duplicati e combinare tutti i file associati.',
+        valueSingleExists:
+          'Il valore esiste già. Conferma per unire i duplicati.',
+        fieldSingleNameExists:
+          'Il nome del campo esiste già. Conferma per unire i duplicati.',
+        fieldExists: 'Il campo esiste già.',
+        fieldSetting: 'Impostazioni campo',
+        changesAffectNewParses: 'Le modifiche riguardano solo le nuove analisi.',
+        restrictDefinedValues: 'Limita ai valori definiti',
+        metadataGenerationSettings: 'Impostazioni generazione metadati',
+        manageMetadata: 'Gestisci metadati',
+        metadata: 'Metadati',
+        values: 'Valori',
+        value: 'Valore',
+        action: 'Azione',
+        field: 'Campo',
+        description: 'Descrizione',
+        fieldName: 'Nome campo',
+        editMetadata: 'Modifica metadati',
+        addMetadata: 'Aggiungi metadati',
+        deleteWarn: 'Questo {{field}} sarà rimosso da tutti i file associati',
+        deleteManageFieldAllWarn:
+          'Questo campo e tutti i suoi valori corrispondenti saranno eliminati da tutti i file associati.',
+        deleteManageValueAllWarn:
+          'Questo valore sarà eliminato da tutti i file associati.',
+        deleteManageFieldSingleWarn:
+          'Questo campo e tutti i suoi valori corrispondenti saranno eliminati da questo file.',
+        deleteManageValueSingleWarn:
+          'Questo valore sarà eliminato da questo file.',
+        deleteSettingFieldWarn: `Questo campo sarà eliminato; i metadati esistenti non saranno interessati.`,
+        deleteSettingValueWarn: `Questo valore sarà eliminato; i metadati esistenti non saranno interessati.`,
+      },
+      redoAll: 'Cancella i chunk esistenti',
+      applyAutoMetadataSettings: 'Applica le impostazioni globali dei metadati automatici',
+      parseFileTip: 'Sei sicuro di voler analizzare?',
+      parseFile: 'Analizza file',
+      emptyMetadata: 'Nessun metadato',
+      metadataField: 'Campo metadati',
+      systemAttribute: 'Attributo di sistema',
       localUpload: 'Caricamento locale',
       fileSize: 'Dimensione file',
       fileType: 'Tipo file',
@@ -159,6 +447,7 @@ export default {
       raptor: 'RAPTOR',
       processingType: 'Tipo di elaborazione',
       dataPipeline: 'Cambia o configura la ingestion pipeline.',
+      dataPipelineTitle: 'Ingestion pipeline',
       operations: 'Operazioni',
       taskId: 'ID Attività',
       duration: 'Durata',
@@ -179,8 +468,8 @@ export default {
       learnMore: 'Introduzione alla pipeline integrata',
       general: 'Generale',
       chunkMethodTab: 'Metodo chunk',
-      testResults: 'Risultati test',
-      testSetting: 'Impostazioni test',
+      testResults: 'Risultati',
+      testSetting: 'Impostazioni',
       retrievalTesting: 'Test di recupero',
       retrievalTestingDescription:
         'Esegui un test di recupero per verificare se RAGFlow riesce a recuperare il contenuto previsto per il LLM.',
@@ -200,7 +489,7 @@ export default {
       localFiles: 'File locali',
       emptyFiles: 'Crea file vuoto',
       webCrawl: 'Web crawl',
-      chunkNumber: 'Numero chunk',
+      chunkNumber: 'Chunk',
       uploadDate: 'Data caricamento',
       chunkMethod: 'Metodo di chunking',
       enabled: 'Abilita',
@@ -208,7 +497,7 @@ export default {
       action: 'Azione',
       parsingStatus: 'Stato analisi',
       parsingStatusTip:
-        'Il tempo di analisi del documento varia in base a diversi fattori. Abilitare funzionalità come Knowledge Graph, RAPTOR, Estrazione automatica domande o Estrazione automatica parole chiave aumenterà significativamente il tempo di elaborazione.',
+        'Il tempo di analisi del documento varia in base a diversi fattori. Abilitare funzionalità come Knowledge Graph, RAPTOR, Estrazione automatica domande o Estrazione automatica parole chiave aumenterà significativamente il tempo di elaborazione. Se la barra di avanzamento si blocca, consulta queste due FAQ: https://ragflow.io/docs/dev/faq#why-does-my-document-parsing-stall-at-under-one-percent.',
       processBeginAt: 'Inizia alle',
       processDuration: 'Durata',
       progressMsg: 'Progresso',
@@ -217,16 +506,16 @@ export default {
       noTestResultsForNotRuned:
         'Nessun test eseguito. I risultati appariranno qui.',
       testingDescription:
-        'Esegui un test di recupero per verificare se RAGFlow riesce a recuperare il contenuto previsto per il LLM.',
+        'Esegui un test di recupero per verificare se RAGFlow riesce a recuperare il contenuto previsto per il LLM. Se hai modificato le impostazioni predefinite, come il peso della similarità delle parole chiave o la soglia di similarità, per ottenere i risultati ottimali, tieni presente che queste modifiche non saranno salvate automaticamente. Devi applicarle alle impostazioni del tuo assistente chat o alle impostazioni del componente agente Recupero.',
       similarityThreshold: 'Soglia di similarità',
       similarityThresholdTip:
-        'RAGFlow utilizza una combinazione di similarità delle parole chiave ponderata e similarità coseno vettoriale ponderata, o una combinazione di similarità delle parole chiave ponderata e punteggio di reranking ponderato durante il recupero.',
+        'RAGFlow utilizza una combinazione di similarità delle parole chiave ponderata e similarità coseno vettoriale ponderata, o una combinazione di similarità delle parole chiave ponderata e punteggio di reranking ponderato durante il recupero. Questo parametro imposta la soglia per le similarità tra la query utente e i chunk. Qualsiasi chunk con un punteggio di similarità inferiore a questa soglia sarà escluso dai risultati. Per impostazione predefinita, la soglia è impostata a 0.2. Ciò significa che solo i chunk con punteggio di similarità ibrida di 20 o superiore saranno recuperati.',
       vectorSimilarityWeight: 'Peso similarità vettoriale',
       vectorSimilarityWeightTip:
-        'Imposta il peso della similarità delle parole chiave nel punteggio di similarità combinato. Il totale dei due pesi deve essere uguale a 1.0.',
+        'Imposta il peso della similarità delle parole chiave nel punteggio di similarità combinato, usato con la similarità coseno vettoriale o con il punteggio di reranking. Il totale dei due pesi deve essere uguale a 1.0.',
       keywordSimilarityWeight: 'Peso similarità parole chiave',
       keywordSimilarityWeightTip:
-        'Imposta il peso della similarità delle parole chiave nel punteggio di similarità combinato. Il totale dei due pesi deve essere uguale a 1.0.',
+        'Imposta il peso della similarità delle parole chiave nel punteggio di similarità combinato, usato con la similarità coseno vettoriale o con il punteggio di reranking. Il totale dei due pesi deve essere uguale a 1.0.',
       testText: 'Testo di test',
       testTextPlaceholder: 'Inserisci la tua domanda qui!',
       testingLabel: 'Esegui',
@@ -238,11 +527,11 @@ export default {
       filesSelected: 'File selezionati',
       upload: 'Carica',
       run: 'Analizza',
-      runningStatus0: 'IN ATTESA',
-      runningStatus1: 'IN ANALISI',
-      runningStatus2: 'ANNULLATO',
-      runningStatus3: 'SUCCESSO',
-      runningStatus4: 'FALLITO',
+      runningStatus0: 'In attesa',
+      runningStatus1: 'In analisi',
+      runningStatus2: 'Annullato',
+      runningStatus3: 'Successo',
+      runningStatus4: 'Fallito',
       pageRanges: 'Intervallo pagine',
       pageRangesTip:
         'Intervallo di pagine da analizzare; le pagine al di fuori di questo intervallo non saranno elaborate.',
@@ -252,10 +541,10 @@ export default {
       toMessage: 'Numero pagina finale mancante (escluso)',
       layoutRecognize: 'Parser PDF',
       layoutRecognizeTip:
-        "Usa un modello visivo per l'analisi del layout PDF per individuare efficacemente titoli, blocchi di testo, immagini e tabelle.",
+        "Usa un modello visivo per l'analisi del layout PDF per individuare efficacemente titoli, blocchi di testo, immagini e tabelle. Se viene scelta l'opzione naive, sarà recuperato solo il testo semplice nel PDF. Nota che questa opzione attualmente funziona SOLO per i documenti PDF.",
       taskPageSize: 'Dimensione pagina attività',
       taskPageSizeMessage: 'Inserisci la dimensione della pagina attività!',
-      taskPageSizeTip: `Durante il riconoscimento del layout, un file PDF viene suddiviso in blocchi ed elaborato in parallelo per aumentare la velocità di elaborazione.`,
+      taskPageSizeTip: `Durante il riconoscimento del layout, un file PDF viene suddiviso in chunk ed elaborato in parallelo per aumentare la velocità di elaborazione. Questo parametro imposta la dimensione di ogni chunk. Una dimensione chunk maggiore riduce la probabilità di dividere il testo continuo tra le pagine.`,
       addPage: 'Aggiungi pagina',
       greaterThan: 'Il valore attuale deve essere maggiore di!',
       greaterThanPrevious:
@@ -264,39 +553,94 @@ export default {
       changeSpecificCategory: 'Cambia categoria specifica',
       uploadTitle: 'Trascina e rilascia il tuo file qui per caricarlo',
       uploadDescription:
-        'Supporta caricamento singolo o multiplo. Limite dimensione file totale per caricamento: 1GB, con limite batch di 32 file.',
+        'Supporta caricamento singolo o multiplo. Per un RAGFlow distribuito localmente: il limite di dimensione totale dei file per caricamento è 1GB, con un limite batch di 32 file. Non c\'è limite al numero totale di file per account. Per cloud.ragflow.io, il limite di dimensione totale dei file per caricamento è 10MB, con ogni file non superiore a 10MB e un massimo di 128 file per account.',
       chunk: 'Chunk',
       bulk: 'Multiplo',
       cancel: 'Annulla',
       close: 'Chiudi',
       rerankModel: 'Modello rerank',
-      rerankPlaceholder: 'Seleziona',
-      rerankTip: `Opzionale. Se lasciato vuoto, RAGFlow userà una combinazione di similarità delle parole chiave ponderata e similarità coseno vettoriale ponderata.`,
+      rerankPlaceholder: 'Seleziona valore',
+      rerankTip: `Opzionale. Se lasciato vuoto, RAGFlow userà una combinazione di similarità delle parole chiave ponderata e similarità coseno vettoriale ponderata; se viene selezionato un modello rerank, un punteggio di reranking ponderato sostituirà la similarità coseno vettoriale ponderata. Tieni presente che l'uso di un modello rerank aumenterà significativamente il tempo di risposta del sistema. Se desideri usare un modello rerank, assicurati di usare un reranker SaaS; se preferisci un modello rerank distribuito localmente, assicurati di avviare RAGFlow con docker-compose-gpu.yml.`,
       topK: 'Top-K',
       topKTip: `Usato insieme al modello Rerank, questa impostazione definisce il numero di chunk di testo da inviare al modello di reranking specificato.`,
       delimiter: `Delimitatore per testo`,
       delimiterTip:
-        'Un delimitatore può consistere in uno o più caratteri speciali. Se sono più caratteri, assicurati che siano racchiusi tra backtick (``). ',
+        'Un delimitatore può consistere in uno o più caratteri speciali. Se sono più caratteri, assicurati che siano racchiusi tra backtick (``). Ad esempio, se configuri i tuoi delimitatori così: \\n`##`;, i tuoi testi saranno separati a interruzioni di riga, doppio cancelletto (##) e punto e virgola.',
+      enableChildrenDelimiter: 'I chunk figli sono usati per il recupero',
+      childrenDelimiter: 'Delimitatore per testo',
+      childrenDelimiterTip:
+        'Un delimitatore può consistere in uno o più caratteri speciali. Se sono più caratteri, assicurati che siano racchiusi tra backtick (``). Ad esempio, se configuri i tuoi delimitatori così: \\n`##`;, i tuoi testi saranno separati a interruzioni di riga, doppio cancelletto (##) e punto e virgola.',
+
       html4excel: 'Excel in HTML',
-      html4excelTip: `Usa con il metodo di chunking Generale. Quando disabilitato, i fogli di calcolo saranno analizzati in coppie chiave-valore. Quando abilitato, saranno analizzati in tabelle HTML.`,
+      html4excelTip: `Usa con il metodo di chunking Generale. Quando disabilitato, i fogli di calcolo (XLSX o XLS (Excel 97-2003)) nel dataset saranno analizzati in coppie chiave-valore. Quando abilitato, saranno analizzati in tabelle HTML, dividendo ogni 12 righe se la tabella originale ha più di 12 righe. Vedi https://ragflow.io/docs/dev/enable_excel2html per i dettagli.`,
       autoKeywords: 'Parole chiave automatiche',
-      autoKeywordsTip: `Estrai automaticamente N parole chiave per ogni chunk per aumentare il loro ranking per le query contenenti quelle parole chiave.`,
+      autoKeywordsTip: `Estrai automaticamente N parole chiave per ogni chunk per aumentare il loro ranking per le query contenenti quelle parole chiave. Tieni presente che saranno consumati token extra dal modello di indicizzazione specificato in 'Configurazione'. Puoi controllare o aggiornare le parole chiave aggiunte per un chunk dalla lista dei chunk. Per i dettagli, vedi https://ragflow.io/docs/dev/autokeyword_autoquestion.`,
       autoQuestions: 'Domande automatiche',
-      autoQuestionsTip: `Estrai automaticamente N domande per ogni chunk per aumentare il loro ranking per le query contenenti quelle domande.`,
+      autoQuestionsTip: `Estrai automaticamente N domande per ogni chunk per aumentare il loro ranking per le query contenenti quelle domande. Puoi controllare o aggiornare le domande aggiunte per un chunk dalla lista dei chunk. Questa funzionalità non interromperà il processo di chunking se si verifica un errore, eccetto che potrebbe aggiungere un risultato vuoto al chunk originale. Tieni presente che saranno consumati token extra dal modello di indicizzazione specificato in 'Configurazione'. Per i dettagli, vedi https://ragflow.io/docs/dev/autokeyword_autoquestion.`,
       redo: 'Vuoi cancellare i {{chunkNum}} chunk esistenti?',
       setMetaData: 'Imposta metadati',
       pleaseInputJson: 'Inserisci JSON',
-      documentMetaTips: `<p>I metadati sono in formato JSON (non ricercabili). Saranno aggiunti al prompt per LLM se qualsiasi chunk di questo documento è incluso nel prompt.</p>`,
+      documentMetaTips: `<p>I metadati sono in formato JSON (non ricercabili). Saranno aggiunti al prompt per LLM se qualsiasi chunk di questo documento è incluso nel prompt.</p>
+<p>Esempi:</p>
+<b>I metadati sono:</b><br>
+<code>
+  {
+      "Author": "Alex Dowson",
+      "Date": "2024-11-12"
+  }
+</code><br>
+<b>Il prompt sarà:</b><br>
+<p>Documento: il_nome_del_documento</p>
+<p>Autore: Alex Dowson</p>
+<p>Data: 2024-11-12</p>
+<p>Frammenti rilevanti come segue:</p>
+<ul>
+<li>  Ecco il contenuto del chunk....</li>
+<li>  Ecco il contenuto del chunk....</li>
+</ul>
+`,
       metaData: 'Metadati',
       deleteDocumentConfirmContent:
-        "Il documento è associato al grafo della conoscenza. Dopo l'eliminazione, le informazioni sui nodi e le relazioni correlate saranno eliminate.",
+        "Il documento è associato al grafo della conoscenza. Dopo l'eliminazione, le informazioni sui nodi e le relazioni correlate saranno eliminate, ma il grafo non sarà aggiornato immediatamente. L'azione di aggiornamento del grafo viene eseguita durante il processo di analisi del nuovo documento che porta l'attività di estrazione del grafo della conoscenza.",
       plainText: 'Naive',
       reRankModelWaring: 'Il modello re-rank richiede molto tempo.',
     },
     knowledgeConfiguration: {
+      randomSeedTip:
+        'Il seme è il punto di partenza per un algoritmo pseudo-casuale che garantisce la riproducibilità dello stesso output in esecuzioni diverse.',
+      datasetDescription: 'Descrivi il tuo dataset',
+      overlappedPercentTip: 'La percentuale di sovrapposizione tra due chunk adiacenti',
+      globalIndexModelTip:
+        'Usato per generare grafi della conoscenza, RAPTOR, metadati automatici, parole chiave automatiche e domande automatiche. Le prestazioni del modello influenzeranno la qualità della generazione.',
+      globalIndexModel: 'Modello di indicizzazione',
+      settings: 'Impostazioni',
+      autoMetadataTip: `Genera automaticamente i metadati. Si applica ai nuovi file durante l'analisi. I file esistenti richiedono una nuova analisi per essere aggiornati (i chunk rimangono preservati). Tieni presente che saranno consumati token extra dal modello di indicizzazione specificato in 'Configurazione'.`,
       imageTableContextWindow: 'Finestra di contesto immagine e tabella',
       imageTableContextWindowTip:
         "Cattura N token di testo sopra e sotto l'immagine e la tabella per fornire un contesto più ricco.",
+      autoMetadata: 'Metadati automatici',
+      mineruOptions: 'Opzioni MinerU',
+      mineruParseMethod: 'Metodo di analisi',
+      mineruParseMethodTip:
+        'Metodo per l\'analisi del PDF: auto (rilevamento automatico), txt (estrazione testo), ocr (riconoscimento ottico dei caratteri)',
+      mineruFormulaEnable: 'Riconoscimento formule',
+      mineruFormulaEnableTip:
+        'Abilita il riconoscimento delle formule. Nota: questo potrebbe non funzionare correttamente per documenti cirillici.',
+      mineruTableEnable: 'Riconoscimento tabelle',
+      mineruTableEnableTip: 'Abilita il riconoscimento e l\'estrazione delle tabelle.',
+      paddleocrOptions: 'Opzioni PaddleOCR',
+      paddleocrApiUrl: 'URL API di PaddleOCR',
+      paddleocrApiUrlTip: 'L\'URL dell\'endpoint API del servizio PaddleOCR',
+      paddleocrApiUrlPlaceholder:
+        'es. https://paddleocr-server.com/layout-parsing',
+      paddleocrAccessToken: 'Token di accesso AI Studio',
+      paddleocrAccessTokenTip: 'Token di accesso per l\'API PaddleOCR (opzionale)',
+      paddleocrAccessTokenPlaceholder: 'Il tuo token AI Studio (opzionale)',
+      paddleocrAlgorithm: 'Algoritmo PaddleOCR',
+      paddleocrAlgorithmTip: 'Algoritmo da usare per l\'analisi PaddleOCR',
+      paddleocrSelectAlgorithm: 'Seleziona algoritmo',
+      paddleocrModelNamePlaceholder: 'es. paddleocr-from-env-1',
+      overlappedPercent: 'Percentuale di sovrapposizione(%)',
       generationScopeTip:
         "Determina se RAPTOR viene generato per l'intero dataset o per un singolo file.",
       scopeDataset: 'Dataset',
@@ -305,15 +649,14 @@ export default {
       autoParse: 'Analisi automatica',
       rebuildTip:
         'Riscarica i file dalla fonte dati collegata e li analizza nuovamente.',
-      baseInfo: 'Informazioni base',
+      baseInfo: 'Base',
       globalIndex: 'Indice globale',
       dataSource: 'Fonte dati',
-      linkSourceSetTip:
-        'Gestisci il collegamento della fonte dati con questo dataset',
+      linkSourceSetTip: 'Gestisci il collegamento della fonte dati con questo dataset',
       linkDataSource: 'Collega fonte dati',
-      tocExtraction: 'Miglioramento TOC',
+      tocExtraction: 'PageIndex',
       tocExtractionTip:
-        'Per i chunk esistenti, genera un indice gerarchico (una directory per file).',
+        " Per i chunk esistenti, genera un indice gerarchico (una directory per file). Durante le query, quando il Miglioramento Directory è attivato, il sistema userà un modello grande per determinare quali elementi della directory sono rilevanti per la domanda dell'utente, identificando così i chunk rilevanti.",
       deleteGenerateModalContent: `
         <p>Eliminando i risultati <strong class='text-text-primary'>{{type}}</strong> generati
         rimuoverai tutte le entità e relazioni derivate da questo dataset.
@@ -322,31 +665,30 @@ export default {
         Vuoi continuare?
       `,
       extractRaptor: 'Estrai Raptor',
-      extractKnowledgeGraph: 'Estrai grafico della conoscenza',
+      extractKnowledgeGraph: 'Estrai grafo della conoscenza',
       filterPlaceholder: 'inserisci filtro',
       fileFilterTip: '',
       fileFilter: 'Filtro file',
       setDefaultTip: '',
       setDefault: 'Imposta come predefinito',
-      editLinkDataPipeline: 'Modifica pipeline di ingestione',
-      linkPipelineSetTip:
-        'Gestisci il collegamento della pipeline di ingestione con questo dataset',
+      editLinkDataPipeline: 'Modifica ingestion pipeline',
+      linkPipelineSetTip: 'Gestisci il collegamento della ingestion pipeline con questo dataset',
       default: 'Predefinito',
       dataPipeline: 'Cambia o configura la ingestion pipeline.',
-      linkDataPipeline: 'Collega pipeline di ingestione',
+      linkDataPipeline: 'Collega ingestion pipeline',
       enableAutoGenerate: 'Abilita generazione automatica',
       teamPlaceholder: 'Seleziona un team.',
       dataFlowPlaceholder: 'Seleziona una pipeline.',
       buildItFromScratch: 'Costruiscilo da zero',
       dataFlow: 'Pipeline',
       parseType: 'Tipo di analisi',
-      manualSetup: 'Scegli pipeline',
+      manualSetup: 'Pipeline',
       builtIn: 'Integrato',
       titleDescription:
-        'Aggiorna la configurazione della tua base di conoscenza qui, in particolare il metodo di chunking.',
-      name: 'Nome base di conoscenza',
-      photo: 'Foto base di conoscenza',
-      photoTip: 'Puoi caricare un’immagine fino a 4 MB.',
+        'Aggiorna la configurazione del tuo dataset qui, in particolare il LLM e i prompt.',
+      name: 'Nome dataset',
+      photo: 'Foto dataset',
+      photoTip: 'Puoi caricare un\'immagine fino a 4 MB.',
       description: 'Descrizione',
       language: 'Lingua documento',
       languageMessage: 'Inserisci la tua lingua!',
@@ -354,13 +696,13 @@ export default {
       permissions: 'Permessi',
       embeddingModel: 'Modello di embedding',
       chunkTokenNumber: 'Dimensione chunk raccomandata',
-      chunkTokenNumberMessage: 'Il numero di token per chunk è richiesto',
+      chunkTokenNumberMessage: 'Il numero di token per chunk per il testo è richiesto',
       embeddingModelTip:
-        'Il modello di embedding predefinito della base di conoscenza. Una volta che la base di conoscenza contiene chunk, quando si cambia il modello di embedding il sistema estrae casualmente alcuni chunk per una verifica di compatibilità, li ricodifica con il nuovo modello di embedding e calcola la similarità coseno tra i vettori nuovi e quelli vecchi. Il cambio è consentito solo se la similarità media del campione è ≥ 0.9. In caso contrario, è necessario eliminare tutti i chunk nella base di conoscenza prima di poterlo modificare.',
+        'Il modello di embedding predefinito usato dal dataset. Una volta che il dataset contiene chunk, quando si cambia il modello di embedding il sistema estrae casualmente alcuni chunk per una verifica di compatibilità, li ricodifica con il nuovo modello di embedding e calcola la similarità coseno tra i vettori nuovi e quelli vecchi. Il cambio è consentito solo se la similarità media del campione è ≥ 0.9. In caso contrario, è necessario eliminare tutti i chunk nel dataset prima di poterlo modificare.',
       permissionsTip:
-        "Se impostato su 'Team', tutti i membri del team potranno gestire la base di conoscenza.",
+        "Se impostato su 'Team', tutti i membri del team potranno gestire il dataset.",
       chunkTokenNumberTip:
-        'Imposta la soglia di token per creare un chunk. Un segmento con meno token di questa soglia sarà combinato con i segmenti successivi.',
+        'Imposta in qualche modo la soglia di token per creare un chunk. Un segmento con meno token di questa soglia sarà combinato con i segmenti successivi finché il conteggio dei token non supera la soglia, a quel punto viene creato un chunk. Non viene creato un nuovo chunk a meno che non si incontri un delimitatore, anche se la soglia viene superata.',
       chunkMethod: 'Metodo di chunking',
       chunkMethodTip: 'Visualizza i suggerimenti a destra.',
       upload: 'Carica',
@@ -369,6 +711,37 @@ export default {
       portugueseBr: 'Portoghese (Brasile)',
       embeddingModelPlaceholder: 'Seleziona un modello di embedding.',
       chunkMethodPlaceholder: 'Seleziona un metodo di chunking.',
+      tableColumnMode: 'Modalità colonna',
+      tableColumnModeAuto: 'Auto',
+      tableColumnModeManual: 'Manuale',
+      tableColumnModeAutoDescription:
+        'Tutte le colonne sono incluse nel testo del chunk e memorizzate come metadati (predefinito RAGFlow).',
+      tableColumnRoles: 'Ruoli colonna',
+      tableColumnRolesTip:
+        'Scegli quali colonne includere nel testo del chunk (indicizzate per la ricerca vettoriale e full-text), solo nei metadati (filtrabili), o entrambi. Le modifiche si applicano alle nuove analisi; rianalizza i documenti esistenti affinché i ruoli abbiano effetto.',
+      tableColumnRoleIndexing: 'Indicizzazione',
+      tableColumnRoleMetadata: 'Metadati',
+      tableColumnRoleBoth: 'Entrambi',
+      tableColumnRolesEmpty:
+        'Carica e analizza un file CSV o Excel per iniziare a configurare i ruoli delle colonne.',
+      tableColumnRolesReparseTip:
+        'Rianalizza i documenti esistenti affinché i nuovi ruoli delle colonne abbiano effetto.',
+      parserLabel: {
+        naive: 'Generale',
+        qa: 'Q&A',
+        resume: 'Curriculum',
+        manual: 'Manuale',
+        table: 'Tabella',
+        paper: 'Paper',
+        book: 'Libro',
+        laws: 'Leggi',
+        presentation: 'Presentazione',
+        picture: 'Immagine',
+        one: 'Uno',
+        audio: 'Audio',
+        email: 'Email',
+        tag: 'Tag',
+      },
       save: 'Salva',
       me: 'Solo io',
       team: 'Team',
@@ -379,34 +752,48 @@ export default {
         'I seguenti screenshot sono forniti per chiarezza.',
       dialogueExamplesTitle: 'visualizza',
       methodEmpty:
-        'Questo mostrerà una spiegazione visiva delle categorie della base di conoscenza',
+        'Questo mostrerà una spiegazione visiva delle categorie del dataset',
       book: `<p>I formati file supportati sono <b>DOCX</b>, <b>PDF</b>, <b>TXT</b>.</p><p>
       Per ogni libro in PDF, imposta gli <i>intervalli di pagine</i> per rimuovere informazioni indesiderate e ridurre il tempo di analisi.</p>`,
       laws: `<p>I formati file supportati sono <b>DOCX</b>, <b>PDF</b>, <b>TXT</b>.</p><p>
-      I documenti legali seguono tipicamente un formato di scrittura rigoroso. Usiamo le caratteristiche del testo per identificare i punti di divisione.
+      I documenti legali seguono tipicamente un formato di scrittura rigoroso. Usiamo le caratteristiche del testo per identificare il punto di divisione.
+      </p><p>
+      Il chunk ha una granularità coerente con 'ARTICOLO', garantendo che tutto il testo di livello superiore sia incluso nel chunk.
       </p>`,
       manual: `<p>Solo <b>PDF</b> è supportato.</p><p>
-      Assumiamo che il manuale abbia una struttura di sezione gerarchica, usando i titoli di sezione più bassi come unità base per il chunking dei documenti.
+      Assumiamo che il manuale abbia una struttura di sezione gerarchica, usando i titoli di sezione più bassi come unità base per il chunking dei documenti. Pertanto, figure e tabelle nella stessa sezione non saranno separate, il che potrebbe risultare in dimensioni chunk maggiori.
       </p>`,
       naive: `<p>I formati file supportati sono <b>MD, MDX, DOCX, XLSX, XLS (Excel 97-2003), PPTX, PDF, TXT, JPEG, JPG, PNG, TIF, GIF, CSV, JSON, EML, HTML</b>.</p>
       <p>Questo metodo suddivide i file usando un metodo 'naive': </p>
       <p>
+      <ul>
       <li>Usa un modello di rilevamento visivo per dividere i testi in segmenti più piccoli.</li>
-      <li>Poi, combina segmenti adiacenti finché il conteggio dei token supera la soglia specificata da 'Numero token chunk', a quel punto viene creato un chunk.</li></p>`,
+      <li>Poi, combina segmenti adiacenti finché il conteggio dei token supera la soglia specificata da 'Numero token chunk per testo', a quel punto viene creato un chunk.</li></ul></p>`,
       paper: `<p>Solo file <b>PDF</b> è supportato.</p><p>
-      I paper saranno divisi per sezione, come <i>abstract, 1.1, 1.2</i>. </p>`,
+      I paper saranno divisi per sezione, come <i>abstract, 1.1, 1.2</i>. </p><p>
+      Questo approccio consente all'LLM di riassumere il paper in modo più efficace e di fornire risposte più complete e comprensibili.
+      Tuttavia, aumenta anche il contesto per le conversazioni IA e aggiunge al costo computazionale per l'LLM. Quindi durante una conversazione, considera di ridurre il valore di '<b>topN</b>'.</p>`,
       presentation: `<p>I formati file supportati sono <b>PDF</b>, <b>PPTX</b>.</p><p>
-      Ogni pagina nelle slide è trattata come un chunk, con la sua immagine in miniatura memorizzata.</p>`,
+      Ogni pagina nelle slide è trattata come un chunk, con la sua immagine in miniatura memorizzata.</p><p>
+      <i>Questo metodo di chunking viene applicato automaticamente a tutti i file PPT caricati, quindi non è necessario specificarlo manualmente.</i></p>`,
       qa: `
       <p>
       Questo metodo di chunking supporta i formati file <b>XLSX</b> e <b>CSV/TXT</b>.
     </p>
+    <ul>
     <li>
-      Se un file è in formato <b>XLSX</b> o <b>XLS (Excel 97-2003)</b>, dovrebbe contenere due colonne senza intestazioni: una per le domande e l'altra per le risposte.
+      Se un file è in formato <b>XLSX</b> o <b>XLS (Excel 97-2003)</b>, dovrebbe contenere due colonne senza intestazioni: una per le domande e l'altra per le risposte, con la colonna delle domande che precede quella delle risposte. Sono accettabili più fogli, purché le colonne siano strutturate correttamente.
     </li>
     <li>
       Se un file è in formato <b>CSV/TXT</b>, deve essere codificato UTF-8 con TAB come delimitatore per separare domande e risposte.
     </li>
+    </ul>
+    <p>
+      <i>
+        Le righe di testo che non seguono le regole sopra saranno ignorate, e
+        ogni coppia Q&A sarà considerata un chunk distinto.
+      </i>
+    </p>
       `,
       resume: `<p>I formati file supportati sono <b>DOCX</b>, <b>PDF</b>, <b>TXT</b>.
       </p><p>
@@ -417,44 +804,65 @@ export default {
       Ecco alcuni prerequisiti e suggerimenti:
       <ul>
     <li>Per file CSV o TXT, il delimitatore tra le colonne deve essere <em><b>TAB</b></em>.</li>
-    <li>La prima riga deve essere intestazioni di colonna.</li>
-    <li>Le intestazioni delle colonne devono essere termini significativi per aiutare la comprensione del tuo LLM.</li>
+    <li>La prima riga deve essere le intestazioni di colonna.</li>
+    <li>Le intestazioni delle colonne devono essere termini significativi per aiutare la comprensione del tuo LLM.
+    È buona pratica giustapporre i sinonimi separati da una barra <i>'/'</i> ed enumerare i valori usando le parentesi, ad esempio: <i>'Genere/Sesso (maschio, femmina)'</i>.<p>
+    Ecco alcuni esempi di intestazioni:<ol>
+        <li>fornitore/venditore<b>'TAB'</b>Colore (Giallo, Blu, Marrone)<b>'TAB'</b>Sesso/Genere (maschio, femmina)<b>'TAB'</b>taglia (M, L, XL, XXL)</li>
+        </ol>
+        </p>
+    </li>
     <li>Ogni riga nella tabella sarà trattata come un chunk.</li>
     </ul>`,
       picture: `
     <p>I file immagine sono supportati, con supporto video in arrivo.</p><p>
     Questo metodo impiega un modello OCR per estrarre testi dalle immagini.
+    </p><p>
+    Se il testo estratto dal modello OCR è ritenuto insufficiente, un LLM visivo specificato sarà usato per fornire una descrizione dell'immagine.
     </p>`,
       one: `
     <p>I formati file supportati sono <b>DOCX, XLSX, XLS (Excel 97-2003), PDF, TXT</b>.
     </p><p>
     Questo metodo tratta ogni documento nella sua interezza come un chunk.
+    </p><p>
+    Applicabile quando richiedi all'LLM di riassumere l'intero documento, purché possa gestire quella quantità di lunghezza del contesto.
     </p>`,
       knowledgeGraph: `<p>I formati file supportati sono <b>DOCX, EXCEL, PPT, IMAGE, PDF, TXT, MD, JSON, EML</b>
 
-<p>Questo approccio suddivide i file usando il metodo 'naive'/'Generale'. Divide un documento in segmenti e poi combina segmenti adiacenti finché il conteggio dei token supera la soglia specificata da 'Numero token chunk', a quel punto viene creato un chunk.</p>
-<p>I chunk vengono poi inviati al LLM per estrarre entità e relazioni per un grafo della conoscenza e una mappa mentale.</p>
+<p>Questo approccio suddivide i file usando il metodo 'naive'/'Generale'. Divide un documento in segmenti e poi combina segmenti adiacenti finché il conteggio dei token supera la soglia specificata da 'Numero token chunk per testo', a quel punto viene creato un chunk.</p>
+<p>I chunk vengono poi inviati all'LLM per estrarre entità e relazioni per un grafo della conoscenza e una mappa mentale.</p>
 <p>Assicurati di impostare i <b>Tipi di entità</b>.</p>`,
-      tag: `<p>Una base di conoscenza che usa il metodo di chunking 'Tag' funziona come un set di tag. Altre basi di conoscenza lo usano per taggare i loro chunk.</p>
-<p>Un set di tag <b>NON</b> sarà direttamente coinvolto in un processo di Retrieval-Augmented Generation (RAG).</p>`,
+      tag: `<p>Un dataset che usa il metodo di chunking 'Tag' funziona come un set di tag. Altri dataset lo usano per taggare i loro chunk, e anche le query a questi dataset sono taggate usando questo set di tag.</p>
+<p>Un set di tag <b>NON</b> sarà direttamente coinvolto in un processo di Retrieval-Augmented Generation (RAG).</p>
+<p>Ogni chunk in questo dataset è una coppia descrizione-tag indipendente.</p>
+<p>I formati file supportati includono <b>XLSX</b> e <b>CSV/TXT</b>:</p>
+<p>Se un file è in formato <b>XLSX</b>, dovrebbe contenere due colonne senza intestazioni: una per le descrizioni dei tag e l'altra per i nomi dei tag, con la colonna Descrizione che precede la colonna Tag. Sono accettabili più fogli, purché le colonne siano strutturate correttamente.</p>
+<p>Se un file è in formato <b>CSV/TXT</b>, deve essere codificato UTF-8 con TAB come delimitatore per separare descrizioni e tag.</p>
+<p>In una colonna Tag, la <b>virgola</b> è usata per separare i tag.</p>
+<i>Le righe di testo che non seguono le regole sopra saranno ignorate.</i>
+`,
       useRaptor: 'RAPTOR',
       useRaptorTip:
-        'RAPTOR può essere usato per attività di question-answering multi-hop. Naviga alla pagina File, clicca Genera > RAPTOR per abilitarlo.',
+        'RAPTOR può essere usato per attività di question-answering multi-hop. Naviga alla pagina File, clicca Genera > RAPTOR per abilitarlo. Vedi https://ragflow.io/docs/dev/enable_raptor per i dettagli.',
       prompt: 'Prompt',
       promptTip:
-        'Usa il prompt di sistema per descrivere il compito per il LLM, specificare come dovrebbe rispondere e delineare altri requisiti.',
+        'Usa il prompt di sistema per descrivere il compito per l\'LLM, specificare come dovrebbe rispondere e delineare altri requisiti vari. Il prompt di sistema è spesso usato insieme a chiavi (variabili), che servono come vari input di dati per l\'LLM. Usa una barra `/` o il pulsante (x) per mostrare le chiavi da usare.',
       promptMessage: 'Il prompt è richiesto',
       promptText: `Per favore riassumi i seguenti paragrafi. Fai attenzione ai numeri, non inventare cose. Paragrafi come segue:
       {cluster_content}
 Quanto sopra è il contenuto che devi riassumere.`,
       maxToken: 'Token massimi',
-      maxTokenTip:
-        'Il numero massimo di token per chunk di riepilogo generato.',
+      maxTokenTip: 'Il numero massimo di token per chunk di riepilogo generato.',
       maxTokenMessage: 'Token massimi richiesti',
       threshold: 'Soglia',
       thresholdTip:
-        'In RAPTOR, i chunk sono raggruppati per la loro similarità semantica. Il parametro Soglia imposta la similarità minima richiesta per raggruppare i chunk insieme.',
+        'In RAPTOR, i chunk sono raggruppati per la loro similarità semantica. Il parametro Soglia imposta la similarità minima richiesta per raggruppare i chunk insieme. Una soglia più alta significa meno chunk in ogni cluster, mentre una più bassa significa di più.',
       thresholdMessage: 'La soglia è richiesta',
+      clusteringMethod: 'Metodo di clustering',
+      clusteringMethodTip:
+        'Seleziona il metodo di clustering RAPTOR. AHC può usare un valore di cluster massimo maggiore, ma può richiedere più memoria su input di grandi dimensioni.',
+      clusteringMethodGmm: 'GMM',
+      clusteringMethodAhc: 'AHC',
       maxCluster: 'Cluster massimo',
       maxClusterTip: 'Il numero massimo di cluster da creare.',
       maxClusterMessage: 'Cluster massimo richiesto',
@@ -463,7 +871,7 @@ Quanto sopra è il contenuto che devi riassumere.`,
       entityTypes: 'Tipi di entità',
       vietnamese: 'Vietnamita',
       pageRank: 'Page rank',
-      pageRankTip: `Puoi assegnare un punteggio PageRank più alto a specifiche basi di conoscenza durante il recupero.`,
+      pageRankTip: `Puoi assegnare un punteggio PageRank più alto a specifici dataset durante il recupero. Il punteggio corrispondente viene aggiunto ai punteggi di similarità ibrida dei chunk recuperati da questi dataset, aumentando il loro ranking. Vedi https://ragflow.io/docs/dev/set_page_rank per i dettagli.`,
       tagName: 'Tag',
       frequency: 'Frequenza',
       searchTags: 'Cerca tag',
@@ -471,43 +879,48 @@ Quanto sopra è il contenuto che devi riassumere.`,
       tagTable: 'Tabella',
       tagSet: 'Set di tag',
       tagSetTip: `
-     <p> Seleziona una o più basi di conoscenza tag per auto-taggare i chunk nella tua base di conoscenza.</p>
+     <p> Seleziona uno o più dataset tag per auto-taggare i chunk nel tuo dataset. Vedi https://ragflow.io/docs/dev/use_tag_sets per i dettagli.</p>
 <p>Anche la query dell'utente sarà auto-taggata.</p>
+Questa funzionalità di auto-tagging migliora il recupero aggiungendo un ulteriore livello di conoscenza specifica del dominio al dataset esistente.
+<p>Differenza tra auto-tag e auto-keyword:</p>
+<ul>
+  <li>Un dataset tag è un set chiuso definito dall'utente, mentre le parole chiave estratte dall'LLM possono essere considerate un set aperto.</li>
+  <li>Devi caricare i set di tag in formati specifici prima di eseguire la funzionalità auto-tag.</li>
+  <li>La funzionalità auto-keyword dipende dall'LLM e consuma un numero significativo di token.</li>
+</ul>
       `,
       topnTags: 'Top-N tag',
       tags: 'Tag',
       addTag: 'Aggiungi tag',
       useGraphRag: 'Grafo della conoscenza',
       useGraphRagTip:
-        'Costruisci un grafo della conoscenza sui chunk di file della base di conoscenza corrente per migliorare il question-answering multi-hop che coinvolge logica annidata.',
+        'Costruisci un grafo della conoscenza sui chunk di file del dataset corrente per migliorare il question-answering multi-hop che coinvolge logica annidata. Vedi https://ragflow.io/docs/dev/construct_knowledge_graph per i dettagli.',
       graphRagMethod: 'Metodo',
       graphRagMethodTip: `
       Light: (Predefinito) Usa prompt forniti da github.com/HKUDS/LightRAG per estrarre entità e relazioni. Questa opzione consuma meno token, meno memoria e meno risorse computazionali.</br>
       General: Usa prompt forniti da github.com/microsoft/graphrag per estrarre entità e relazioni.</br>
-      NER: Usa spaCy NER e l'estrazione di parole chiave basata su regole per estrarre entità e relazioni. Non è necessario un LLM per l'estrazione, rendendola veloce ed efficiente nelle risorse.`,
+      NER: Usa spaCy NER e l'estrazione di parole chiave basata su regole per estrarre entità e relazioni. Non è necessario un LLM per l'estrazione stessa, rendendola veloce ed efficiente nelle risorse.`,
+      graphRagBatchChunkTokenSize: 'Dimensione token chunk batch',
+      graphRagBatchChunkTokenSizeTip:
+        'Il limite di token per ogni batch di chunk inviati all\'LLM per l\'estrazione di entità e relazioni del grafo della conoscenza. Non applicato a NER.',
       resolution: 'Risoluzione entità',
-      resolutionTip: `Un interruttore di deduplicazione entità. Quando abilitato, il LLM combinerà entità simili per costruire un grafo più accurato`,
+      resolutionTip: `Un interruttore di deduplicazione entità. Quando abilitato, l'LLM combinerà entità simili - es. '2025' e 'l'anno 2025', o 'IT' e 'Information Technology' - per costruire un grafo più accurato`,
       community: 'Report comunità',
       communityTip:
-        'In un grafo della conoscenza, una comunità è un cluster di entità collegate da relazioni. Puoi far generare al LLM un abstract per ogni comunità, noto come report comunità.',
+        'In un grafo della conoscenza, una comunità è un cluster di entità collegate da relazioni. Puoi far generare all\'LLM un abstract per ogni comunità, noto come report comunità. Vedi qui per maggiori informazioni: https://www.microsoft.com/en-us/research/blog/graphrag-improving-global-search-via-dynamic-community-selection/',
       theDocumentBeingParsedCannotBeDeleted:
         'Il documento in fase di analisi non può essere eliminato',
-      paddleocrOptions: 'Opzioni PaddleOCR',
-      paddleocrApiUrl: 'URL API di PaddleOCR',
-      paddleocrApiUrlTip: 'URL dell’endpoint API del servizio PaddleOCR',
-      paddleocrApiUrlPlaceholder:
-        'Ad esempio: https://paddleocr-server.com/layout-parsing',
-      paddleocrAccessToken: 'Token di accesso AI Studio',
-      paddleocrAccessTokenTip:
-        'Token di accesso per l’API PaddleOCR (facoltativo)',
-      paddleocrAccessTokenPlaceholder: 'Il tuo token AI Studio (facoltativo)',
-      paddleocrAlgorithm: 'Algoritmo PaddleOCR',
-      paddleocrAlgorithmTip:
-        'Algoritmo utilizzato per l’elaborazione PaddleOCR',
-      paddleocrSelectAlgorithm: 'Seleziona algoritmo',
-      paddleocrModelNamePlaceholder: 'Ad esempio: paddleocr-ambiente-1',
+      lastWeek: 'dalla settimana scorsa',
     },
     chunk: {
+      type: 'Tipo',
+      docType: {
+        image: 'Immagine',
+        table: 'Tabella',
+        text: 'Testo',
+      },
+      size: 'Dimensione',
+      uploadedTime: 'Ora di caricamento',
       chunk: 'Chunk',
       bulk: 'Multiplo',
       selectAll: 'Seleziona tutto',
@@ -519,6 +932,8 @@ Quanto sopra è il contenuto che devi riassumere.`,
       enabled: 'Abilitato',
       disabled: 'Disabilitato',
       keyword: 'Parola chiave',
+      image: 'Immagine',
+      imageUploaderTitle: 'Carica una nuova immagine per aggiornare questo chunk immagine',
       function: 'Funzione',
       chunkMessage: 'Inserisci un valore!',
       full: 'Testo completo',
@@ -554,34 +969,47 @@ Quanto sopra è il contenuto che devi riassumere.`,
       sendPlaceholder: "Scrivi all'assistente...",
       chatConfiguration: 'Configurazione chat',
       chatConfigurationDescription:
-        'Imposta un assistente chat per i tuoi dataset selezionati (basi di conoscenza) qui!',
+        ' Imposta un assistente chat per i tuoi dataset selezionati (dataset) qui! 💕',
       assistantName: 'Nome assistente',
       assistantNameMessage: "Il nome dell'assistente è richiesto",
       namePlaceholder: 'es. Resume Jarvis',
       assistantAvatar: 'Avatar assistente',
       language: 'Lingua',
       emptyResponse: 'Risposta vuota',
-      emptyResponseTip: `Imposta questa come risposta se non vengono recuperati risultati dalle basi di conoscenza per la tua query, oppure lascia questo campo vuoto per permettere al LLM di improvvisare quando non viene trovato nulla.`,
-      emptyResponseMessage: `La risposta vuota sarà attivata quando nulla di rilevante viene recuperato dalle basi di conoscenza. Devi svuotare il campo 'Risposta vuota' se non è selezionata nessuna base di conoscenza.`,
+      emptyResponseTip: `Imposta questa come risposta se non vengono recuperati risultati dai dataset per la tua query, oppure lascia questo campo vuoto per permettere all'LLM di improvvisare quando non viene trovato nulla.`,
+      emptyResponseMessage: `La risposta vuota sarà attivata quando nulla di rilevante viene recuperato dai dataset. Devi svuotare il campo 'Risposta vuota' se non è selezionato nessun dataset.`,
+      emptyResponsePlaceholder:
+        'La risposta che stai cercando non è stata trovata nel dataset!',
       setAnOpener: 'Saluto di apertura',
       setAnOpenerInitial: `Ciao! Sono il tuo assistente. Cosa posso fare per te?`,
       setAnOpenerTip: 'Imposta un saluto di apertura per gli utenti.',
       knowledgeBases: 'Dataset',
+      knowledgeBasesPlaceholder: 'Seleziona valore',
       knowledgeBasesMessage: 'Seleziona',
       knowledgeBasesTip:
-        'Seleziona i dataset da associare a questo assistente chat. Una base di conoscenza vuota non apparirà nella lista a discesa.',
+        'Seleziona i dataset da associare a questo assistente chat. Un dataset vuoto non apparirà nella lista a discesa.',
       system: 'Prompt di sistema',
-      systemInitialValue: `Sei un assistente intelligente. Per favore riassumi il contenuto della base di conoscenza per rispondere alla domanda. Elenca i dati nella base di conoscenza e rispondi in dettaglio. Quando tutto il contenuto della base di conoscenza è irrilevante per la domanda, la tua risposta deve includere la frase "La risposta che stai cercando non è stata trovata nella base di conoscenza!" Le risposte devono considerare la cronologia della chat.
-      Ecco la base di conoscenza:
-      {knowledge}
-      Quanto sopra è la base di conoscenza.`,
+      systemPlaceholder: `Sei un assistente intelligente. La tua funzione principale è rispondere alle domande basandoti rigorosamente sulla knowledge base fornita.
+
+**Regole essenziali:**
+  - La tua risposta deve derivare **esclusivamente** da questo dataset: {knowledge}.
+  - **Quando le informazioni sono disponibili**: riassumi il contenuto per dare una risposta dettagliata.
+  - **Quando le informazioni non sono disponibili**: la tua risposta deve contenere esattamente questa frase: "La risposta che stai cercando non è stata trovata nella knowledge base!"
+  - **Considera sempre** l'intera cronologia della conversazione.`,
+      systemInitialValue: `Sei un assistente intelligente. La tua funzione principale è rispondere alle domande basandoti rigorosamente sulla knowledge base fornita.
+
+      **Regole essenziali:**
+        - La tua risposta deve derivare **esclusivamente** da questo dataset: \`{knowledge}\`.
+        - **Quando le informazioni sono disponibili**: riassumi il contenuto per dare una risposta dettagliata.
+        - **Quando le informazioni non sono disponibili**: la tua risposta deve contenere esattamente questa frase: "La risposta che stai cercando non è stata trovata nel dataset!"
+        - **Considera sempre** l'intera cronologia della conversazione.`,
       systemMessage: 'Inserisci!',
       systemTip:
-        'I tuoi prompt o istruzioni per il LLM, inclusi ma non limitati al suo ruolo, la lunghezza desiderata, il tono e la lingua delle sue risposte.',
+        'I tuoi prompt o istruzioni per l\'LLM, inclusi ma non limitati al suo ruolo, la lunghezza desiderata, il tono e la lingua delle sue risposte. Se il tuo modello ha supporto nativo per il ragionamento, puoi aggiungere //no_thinking al prompt per fermare il ragionamento.',
       topN: 'Top N',
-      topNTip: `Non tutti i chunk con punteggio di similarità sopra la 'soglia di similarità' saranno inviati al LLM. Questo seleziona 'Top N' chunk da quelli recuperati.`,
+      topNTip: `Non tutti i chunk con punteggio di similarità sopra la 'soglia di similarità' saranno inviati all'LLM. Questo seleziona 'Top N' chunk da quelli recuperati.`,
       variable: 'Variabile',
-      variableTip: `Usate insieme alle API di gestione dell'assistente chat di RAGFlow, le variabili possono aiutare a sviluppare strategie di prompt di sistema più flessibili.`,
+      variableTip: `Usate insieme alle API di gestione dell'assistente chat di RAGFlow, le variabili possono aiutare a sviluppare strategie di prompt di sistema più flessibili. Le variabili definite saranno usate dal 'Prompt di sistema' come parte dei prompt per l'LLM. {knowledge} è una variabile speciale riservata che rappresenta i chunk recuperati dal/i dataset specificato/i, e tutte le variabili devono essere racchiuse tra parentesi graffe {} nel 'Prompt di sistema'. Vedi https://ragflow.io/docs/dev/set_chat_variables per i dettagli.`,
       add: 'Aggiungi',
       key: 'Chiave',
       optional: 'Opzionale',
@@ -597,14 +1025,14 @@ Quanto sopra è il contenuto che devi riassumere.`,
       precise: 'Preciso',
       balance: 'Bilanciato',
       custom: 'Personalizzato',
-      freedomTip: `Una scorciatoia per le impostazioni 'Temperatura', 'Top P', 'Penalità di presenza' e 'Penalità di frequenza', che indica il livello di libertà del modello.`,
+      freedomTip: `Una scorciatoia per le impostazioni 'Temperatura', 'Top P', 'Penalità di presenza' e 'Penalità di frequenza', che indica il livello di libertà del modello. Questo parametro ha tre opzioni: seleziona 'Improvvisa' per produrre risposte più creative; seleziona 'Preciso' (predefinito) per produrre risposte più conservative; 'Bilanciato' è una via di mezzo tra 'Improvvisa' e 'Preciso'.`,
       temperature: 'Temperatura',
       temperatureMessage: 'La temperatura è richiesta',
       temperatureTip: `Questo parametro controlla la casualità delle previsioni del modello. Una temperatura più bassa produce risposte più conservative, mentre una temperatura più alta produce risposte più creative e diverse.`,
       topP: 'Top P',
       topPMessage: 'Top P è richiesto',
       topPTip:
-        'Conosciuto anche come "campionamento del nucleo", questo parametro imposta una soglia per selezionare un set più piccolo delle parole più probabili da cui campionare.',
+        'Conosciuto anche come "campionamento del nucleo", questo parametro imposta una soglia per selezionare un set più piccolo delle parole più probabili da cui campionare, escludendo quelle meno probabili.',
       presencePenalty: 'Penalità di presenza',
       presencePenaltyMessage: 'La penalità di presenza è richiesta',
       presencePenaltyTip:
@@ -615,7 +1043,7 @@ Quanto sopra è il contenuto che devi riassumere.`,
         'Simile alla penalità di presenza, questo riduce la tendenza del modello a ripetere le stesse parole frequentemente.',
       maxTokens: 'Token massimi',
       maxTokensMessage: 'Token massimi richiesti',
-      maxTokensTip: `La dimensione massima del contesto dell'modello; un valore non valido o errato causerà un errore. Valore predefinito 512.`,
+      maxTokensTip: `La dimensione massima del contesto del modello; un valore non valido o errato causerà un errore. Valore predefinito 512.`,
       maxTokensInvalidMessage: 'Inserisci un numero valido per Token massimi.',
       maxTokensMinMessage: 'Token massimi non può essere inferiore a 0.',
       quote: 'Mostra citazione',
@@ -628,7 +1056,7 @@ Quanto sopra è il contenuto che devi riassumere.`,
       speed: 'Velocità output token',
       tokens: 'Consuma il numero di token',
       round: 'Numero interazione sessione',
-      thumbUp: 'Soddisfazione cliente',
+      thumbUp: 'soddisfazione cliente',
       preview: 'Anteprima',
       embedded: 'Incorporato',
       serviceApiEndpoint: 'Endpoint API servizio',
@@ -640,6 +1068,17 @@ Quanto sopra è il contenuto che devi riassumere.`,
       created: 'Creato',
       action: 'Azione',
       embedModalTitle: 'Incorpora nella pagina web',
+      published: 'Pubblicato',
+      publishedTooltip:
+        'Usa la versione pubblicata per questo embed. Quando abilitato, l\'URL generato include release=true.',
+      embedType: 'Tipo di embed',
+      fullscreenChat: 'Chat a schermo intero (iframe tradizionale)',
+      floatingWidget: 'Widget fluttuante (stile Intercom)',
+      theme: 'Tema',
+      light: 'Chiaro',
+      dark: 'Scuro',
+      enableStreaming: 'Abilita risposte in streaming',
+      muteWidget: 'Silenzia suoni del widget',
       comingSoon: 'Prossimamente',
       fullScreenTitle: 'Incorporamento completo',
       fullScreenDescription:
@@ -665,47 +1104,68 @@ Quanto sopra è il contenuto che devi riassumere.`,
         'Questo ottimizza le query utente usando il contesto in una conversazione multi-round. Quando abilitato, consumerà token LLM aggiuntivi.',
       howUseId: "Come usare l'ID chat?",
       description: "Descrizione dell'assistente",
-      descriptionPlaceholder: 'es. Un assistente chat per curriculum.',
+      descriptionPlaceholder: "Sono un assistente chat.",
       useKnowledgeGraph: 'Usa grafo della conoscenza',
       useKnowledgeGraphTip:
-        'Se usare il/i grafo/i della conoscenza nella/e base/i di conoscenza specificata/e durante il recupero per il question answering multi-hop.',
+        'Se usare il/i grafo/i della conoscenza nel/i dataset specificato/i durante il recupero per il question answering multi-hop. Quando abilitato, ciò comporterebbe ricerche iterative attraverso chunk di entità, relazioni e report di comunità, aumentando notevolmente il tempo di recupero.',
       keyword: 'Analisi parole chiave',
-      keywordTip: `Usa LLM per analizzare le domande dell'utente, estrarre parole chiave che saranno enfatizzate durante il calcolo della rilevanza.`,
+      keywordTip: `Usa LLM per analizzare le domande dell'utente, estrarre parole chiave che saranno enfatizzate durante il calcolo della rilevanza. Funziona bene con query lunghe ma aumenterà il tempo di risposta.`,
       languageTip:
         "Permette la riscrittura delle frasi con la lingua specificata o usa per default l'ultima domanda se non selezionata.",
       avatarHidden: 'Nascondi avatar',
       locale: 'Locale',
       selectLanguage: 'Seleziona una lingua',
       reasoning: 'Ragionamento',
-      reasoningTip: `Se abilitare un flusso di lavoro di ragionamento durante la risposta alle domande, come visto in modelli come Deepseek-R1 o OpenAI o1.`,
+      reasoningTip: `Se abilitare un flusso di lavoro di ragionamento durante la risposta alle domande, come visto in modelli come Deepseek-R1 o OpenAI o1. Quando abilitato, ciò permette al modello di accedere a conoscenza esterna e affrontare domande complesse passo dopo passo, sfruttando tecniche come il ragionamento a catena di pensiero. Questo approccio migliora la capacità del modello di fornire risposte accurate scomponendo i problemi in passaggi gestibili, migliorando le prestazioni su compiti che richiedono ragionamento logico e pensiero multi-step.`,
       tavilyApiKeyTip:
-        'Se una chiave API è impostata correttamente qui, le ricerche web basate su Tavily saranno usate per integrare il recupero dalla base di conoscenza.',
+        'Se una chiave API è impostata correttamente qui, le ricerche web basate su Tavily saranno usate per integrare il recupero dal dataset.',
       tavilyApiKeyMessage: 'Inserisci la tua chiave API Tavily',
       tavilyApiKeyHelp: 'Come ottenerla?',
       crossLanguage: 'Ricerca cross-lingua',
+      crossLanguagePlaceholder: 'Seleziona valore',
       crossLanguageTip: `Seleziona una o più lingue per la ricerca cross-lingua. Se non viene selezionata nessuna lingua, il sistema cerca con la query originale.`,
       createChat: 'Crea chat',
       metadata: 'Metadati',
       metadataTip:
-        'Il filtraggio dei metadati è il processo di utilizzo degli attributi dei metadati per affinare e controllare il recupero delle informazioni rilevanti.',
+        'Il filtraggio dei metadati è il processo di utilizzo degli attributi dei metadati (come tag, categorie o permessi di accesso) per affinare e controllare il recupero delle informazioni rilevanti all\'interno di un sistema.',
       conditions: 'Condizioni',
+      metadataKeys: 'Elementi filtrabili',
       addCondition: 'Aggiungi condizione',
       meta: {
         disabled: 'Disabilitato',
         auto: 'Automatico',
         manual: 'Manuale',
+        semi_auto: 'Semi-automatico',
       },
       cancel: 'Annulla',
       chatSetting: 'Impostazioni chat',
-      tocEnhance: 'Miglioramento TOC',
-      tocEnhanceTip: `Durante l'analisi del documento, sono state generate informazioni sull'indice. Questo permette al modello grande di restituire elementi dell'indice rilevanti per la query dell'utente.`,
+      tocEnhance: 'PageIndex',
+      tocEnhanceTip: ` Durante l'analisi del documento, sono state generate informazioni sull'indice (vedi l'opzione 'Abilita estrazione indice' nel metodo Generale). Questo permette al modello grande di restituire elementi dell'indice rilevanti per la query dell'utente, usando così questi elementi per recuperare i chunk correlati e applicare una ponderazione a questi chunk durante il processo di ordinamento. Questo approccio imita il comportamento umano di ricerca delle informazioni nei libri.`,
+      batchDeleteSessions: 'Eliminazione multipla',
+      deleteSelectedConfirm: 'Eliminare le {{count}} sessioni selezionate?',
     },
     setting: {
+      Verify: 'Verifica',
+      keyValid: 'La tua chiave API è valida.',
+      keyInvalid: 'La tua chiave API non è valida.',
+      enableToolCall: 'Abilita chiamata strumenti',
+      enableToolCallTip:
+        'Permette a questo modello di chiamare strumenti quando il tipo di modello selezionato supporta le chiamate a strumenti.',
       deleteModel: 'Elimina modello',
+      bedrockCredentialsHint:
+        'Suggerimento: lascia Access Key / Secret Key vuoti per usare l\'autenticazione AWS IAM.',
+      awsAuthModeAccessKeySecret: 'Access Key',
+      awsAuthModeIamRole: 'IAM Role',
+      awsAuthModeAssumeRole: 'Assume Role',
+      awsAccessKeyId: 'AWS Access Key ID',
+      awsSecretAccessKey: 'AWS Secret Access Key',
+      awsRoleArn: 'AWS Role ARN',
+      awsRoleArnMessage: 'Inserisci AWS Role ARN',
+      awsAssumeRoleTip:
+        'Se selezioni questa modalità, l\'istanza Amazon EC2 assumerà il suo ruolo esistente per accedere ai servizi AWS. Non sono richieste credenziali aggiuntive.',
       modelEmptyTip:
         'Nessun modello disponibile. <br>Aggiungi modelli dal pannello a destra.',
-      sourceEmptyTip:
-        'Nessuna fonte dati aggiunta. Selezionane una qui sotto per connetterti.',
+      sourceEmptyTip: 'Nessuna fonte dati aggiunta. Selezionane una qui sotto per connetterti.',
       seconds: 'secondi',
       minutes: 'minuti',
       edit: 'Modifica',
@@ -714,6 +1174,303 @@ Quanto sopra è il contenuto che devi riassumere.`,
       cropImage: 'Ritaglia immagine',
       selectModelPlaceholder: 'Seleziona modello',
       configureModelTitle: 'Configura modello',
+      connectorNameTip: 'Un nome descrittivo per il connettore',
+      syncDeletedFiles: 'Sincronizza file eliminati',
+      confluenceIsCloudTip:
+        'Spunta se questa è un\'istanza Confluence Cloud, deseleziona per Confluence Server/Data Center',
+      confluenceWikiBaseUrlTip:
+        'L\'URL base della tua istanza Confluence (es. https://your-domain.atlassian.net/wiki)',
+      confluenceSpaceKeyTip:
+        'Opzionale: specifica una chiave spazio per limitare la sincronizzazione a uno spazio specifico. Lascia vuoto per sincronizzare tutti gli spazi accessibili. Per più spazi, separa con virgole (es. DEV,DOCS,HR)',
+      s3PrefixTip: `Specifica il percorso della cartella all'interno del tuo bucket S3 da cui recuperare i file.
+Esempio: general/v2/`,
+      S3CompatibleEndpointUrlTip: `Richiesto per Storage Box compatibile con S3. Specifica l'URL dell'endpoint compatibile con S3.
+Esempio: https://fsn1.your-objectstorage.com`,
+      S3CompatibleAddressingStyleTip: `Richiesto per Storage Box compatibile con S3. Specifica lo stile di indirizzamento compatibile con S3.
+Esempio: Virtual Hosted Style`,
+      addDataSourceModalTitle: 'Crea il tuo connettore {{name}}',
+      deleteSourceModalTitle: 'Elimina fonte dati',
+      deleteSourceModalContent: `
+      <p>Sei sicuro di voler eliminare questo collegamento alla fonte dati?</p>`,
+      deleteSourceModalConfirmText: 'Conferma',
+      errorMsg: 'Messaggio di errore',
+      newDocs: 'Nuovi documenti',
+      timeStarted: 'Ora di inizio',
+      log: 'Log',
+      rssDescription:
+        'Connettiti a un feed RSS o Atom pubblico e sincronizza le voci del feed nella tua knowledge base.',
+      confluenceDescription:
+        'Integra il tuo workspace Confluence per cercare nella documentazione.',
+      s3Description:
+        'Connettiti al tuo bucket AWS S3 per importare e sincronizzare i file memorizzati.',
+      google_cloud_storageDescription:
+        'Connetti il tuo bucket Google Cloud Storage per importare e sincronizzare i file.',
+      r2Description:
+        'Connetti il tuo bucket Cloudflare R2 per importare e sincronizzare i file.',
+      oci_storageDescription:
+        'Connetti il tuo bucket Oracle Cloud Object Storage per importare e sincronizzare i file.',
+      discordDescription:
+        'Collega il tuo server Discord per accedere e analizzare i dati delle chat.',
+      notionDescription:
+        'Sincronizza pagine e database da Notion per il recupero della conoscenza.',
+      google_driveDescription:
+        'Connetti il tuo Google Drive tramite OAuth e sincronizza cartelle o drive specifici.',
+      gmailDescription: 'Connetti il tuo Gmail tramite OAuth per sincronizzare le email.',
+      webdavDescription: 'Connettiti a server WebDAV per sincronizzare i file.',
+      webdavRemotePathTip:
+        'Opzionale: specifica un percorso cartella sul server WebDAV (es. /Documents). Lascia vuoto per sincronizzare dalla radice.',
+      google_driveTokenTip:
+        'Carica il JSON del token OAuth generato dall\'helper OAuth o dalla Google Cloud Console. Puoi anche caricare un JSON client_secret da un\'applicazione "installed" o "web". Se questa è la tua prima sincronizzazione, si aprirà una finestra del browser per completare il consenso OAuth. Se il JSON contiene già un refresh token, sarà riutilizzato automaticamente.',
+      google_drivePrimaryAdminTip:
+        'Indirizzo email che ha accesso al contenuto del Drive da sincronizzare',
+      zendeskDescription:
+        'Connetti il tuo Zendesk per sincronizzare ticket, articoli e altri contenuti.',
+      google_driveMyDriveEmailsTip:
+        'Email separate da virgola i cui contenuti "My Drive" devono essere indicizzati (includi l\'admin primario).',
+      google_driveSharedFoldersTip:
+        'Link a cartelle Google Drive separati da virgola da scansionare.',
+      gmailPrimaryAdminTip:
+        'Email admin primaria con accesso Gmail / Workspace, usata per enumerare gli utenti del dominio e come account di sincronizzazione predefinito.',
+      gmailTokenTip:
+        'Carica il JSON OAuth generato dalla Google Console. Se contiene solo credenziali client, esegui una volta la verifica basata su browser per generare refresh token a lunga durata.',
+      dropboxDescription:
+        'Connetti il tuo Dropbox per sincronizzare file e cartelle da un account scelto.',
+      teamsDescription:
+        'Connetti Microsoft Teams tramite Microsoft Graph per sincronizzare post e risposte dei canali.',
+      teamsTenantIdTip:
+        'ID tenant Azure AD. Richiede un\'app con permessi applicativi Team.ReadBasic.All e ChannelMessage.Read.All (consenso admin).',
+      slackDescription:
+        'Connetti il tuo workspace Slack per sincronizzare messaggi e thread dei canali.',
+      slackBotTokenTip:
+        'Token OAuth utente bot Slack (inizia con xoxb-). L\'app necessita degli scope channels:read, channels:history e users:read.',
+      slackChannelsTip:
+        'Opzionale: nomi dei canali da sincronizzare (es. general). Lascia vuoto per sincronizzare tutti i canali accessibili.',
+      sharepointDescription:
+        'Connetti un sito SharePoint tramite Microsoft Graph per sincronizzare le sue librerie documenti.',
+      sharepointSiteUrlTip:
+        'URL completo del sito SharePoint da indicizzare, es. https://contoso.sharepoint.com/sites/MySite. Richiede un\'app Azure AD con permessi applicativi Sites.Read.All e Files.Read.All (consenso admin).',
+      bitbucketDescription: 'Connetti Bitbucket per sincronizzare il contenuto delle PR.',
+      bitbucketTopWorkspaceTip:
+        'Il workspace Bitbucket da indicizzare (es. "atlassian" da https://bitbucket.org/atlassian/workspace ).',
+      bitbucketRepositorySlugsTip:
+        'Slug dei repository separati da virgola. Es. repo-one,repo-two',
+      bitbucketProjectsTip: 'Chiavi progetto separate da virgola. Es. PROJ1,PROJ2',
+      bitbucketWorkspaceTip:
+        'Questo connettore indicizzerà tutti i repository nel workspace.',
+      boxDescription: 'Connetti il tuo drive Box per sincronizzare file e cartelle.',
+
+      githubDescription:
+        'Connetti GitHub per sincronizzare pull request e issue per il recupero.',
+      airtableDescription:
+        'Connettiti ad Airtable e sincronizza i file da una tabella specificata all\'interno di un workspace designato.',
+      dingtalkAITableDescription:
+        'Connettiti a Dingtalk AI Table e sincronizza i record da una tabella specificata.',
+      gitlabDescription:
+        'Connetti GitLab per sincronizzare repository, issue, merge request e documentazione correlata.',
+      asanaDescription:
+        'Connettiti ad Asana e sincronizza i file da un workspace specificato.',
+      imapDescription:
+        'Connettiti alla tua casella IMAP per sincronizzare le email per il recupero della conoscenza.',
+      dropboxAccessTokenTip:
+        'Genera un token di accesso a lunga durata nella Dropbox App Console con gli scope files.metadata.read, files.content.read e sharing.read.',
+      moodleDescription:
+        'Connettiti al tuo LMS Moodle per sincronizzare contenuti dei corsi, forum e risorse.',
+      moodleUrlTip:
+        'L\'URL base della tua istanza Moodle (es. https://moodle.university.edu). Non includere /webservice o /login.',
+      moodleTokenTip:
+        'Genera un token di servizio web in Moodle: vai a Amministrazione del sito → Server → Servizi web → Gestisci token. L\'utente deve essere iscritto ai corsi che vuoi sincronizzare.',
+      seafileDescription:
+        'Connettiti al tuo server SeaFile per sincronizzare file e documenti dalle tue librerie.',
+      seafileUrlTip:
+        'L\'URL completo del tuo server SeaFile incluso il protocollo. Esempio: https://seafile.example.com - Non includere una barra finale o alcun percorso dopo il dominio.',
+      seafileAccountScopeTip:
+        'Sincronizza tutte le librerie visibili al token API account qui sotto.',
+      seafileTokenPanelHeading: 'Fornisci uno di questi metodi di autenticazione:',
+      seafileTokenPanelAccountBullet: '- concede accesso a tutte le tue librerie.',
+      seafileTokenPanelLibraryBullet:
+        '— limitato a una singola libreria (più sicuro).',
+      seafileValidationAccountTokenRequired:
+        'Il token API account è richiesto per l\'ambito Intero account',
+      seafileValidationTokenRequired:
+        'Fornisci un token API account o un token libreria',
+      seafileValidationLibraryIdRequired: 'L\'ID libreria è richiesto',
+      seafileValidationDirectoryPathRequired: 'Il percorso directory è richiesto',
+      seafileSyncScopeTip:
+        'Controlla cosa viene sincronizzato: ' +
+        '(1) Intero account - Sincronizza tutte le librerie a cui il tuo token ha accesso. Richiede un token API account. ' +
+        '(2) Singola libreria - Sincronizza tutti i file all\'interno di una libreria specifica. Richiede l\'ID libreria e un token API account o un token API libreria. ' +
+        '(3) Directory specifica - Sincronizza solo i file all\'interno di una cartella specifica dentro una libreria. Richiede l\'ID libreria, il percorso della cartella all\'interno di quella libreria, e un token API account o un token API libreria.',
+      seafileTokenTip:
+        'Il tuo token API SeaFile a livello di account. ' +
+        'Concede accesso a tutte le librerie visibili al tuo account. ' +
+        'Richiesto quando l\'ambito di sincronizzazione è "Intero account". ' +
+        'Per "Singola libreria" o "Directory specifica" puoi usare questo token o un token API libreria invece.',
+      seafileRepoTokenTip:
+        'Un token API limitato a una libreria che concede accesso solo a una libreria specifica. ' +
+        'Può essere usato al posto del token API account per gli ambiti di sincronizzazione "Singola libreria" e "Directory specifica".',
+      seafileRepoIdTip:
+        'L\'identificatore univoco (UUID) della libreria SeaFile che vuoi sincronizzare. ' +
+        'Puoi trovarlo nella barra degli indirizzi del browser quando apri la libreria nell\'interfaccia web SeaFile. ' +
+        'Esempio: 7a9e1b3c-4d5f-6a7b-8c9d-0e1f2a3b4c5d. ' +
+        'Richiesto quando l\'ambito di sincronizzazione è "Singola libreria" o "Directory specifica".',
+      seafileSyncPathTip:
+        'Il percorso assoluto della cartella da sincronizzare all\'interno della libreria specificata dall\'ID libreria sopra. ' +
+        'Deve iniziare con una barra in avanti. ' +
+        'Tutti i file e le sottocartelle sotto questo percorso saranno inclusi ricorsivamente. ' +
+        'Esempio: /Documents/Reports. ' +
+        'Importante: la cartella deve esistere all\'interno della libreria specificata. ' +
+        'I percorsi al di fuori della libreria non sono supportati. ' +
+        'Usato solo quando l\'ambito di sincronizzazione è "Directory specifica".',
+      seafileIncludeSharedTip:
+        'Quando abilitato, le librerie che altri utenti hanno condiviso con te sono incluse nella sincronizzazione. ' +
+        'Quando disabilitato, solo le librerie di proprietà del tuo account sono sincronizzate. ' +
+        'Si applica solo quando l\'ambito di sincronizzazione è "Intero account".',
+      seafileBatchSizeTip:
+        'Il numero di documenti elaborati e restituiti per batch durante la sincronizzazione. ' +
+        'Un valore più piccolo usa meno memoria ma può essere più lento nel complesso. ' +
+        'Predefinito: 100.',
+      jiraDescription:
+        'Connetti il tuo workspace Jira per sincronizzare issue, commenti e allegati.',
+      jiraBaseUrlTip:
+        'URL base del tuo sito Jira (es. https://your-domain.atlassian.net).',
+      jiraProjectKeyTip:
+        'Opzionale: limita la sincronizzazione a una singola chiave progetto (es. ENG).',
+      jiraJqlTip:
+        'Filtro JQL opzionale. Lascia vuoto per affidarti ai filtri progetto/tempo.',
+      jiraBatchSizeTip:
+        'Numero massimo di issue richieste da Jira per batch.',
+      jiraCommentsTip:
+        'Includi i commenti Jira nel documento markdown generato.',
+      jiraAttachmentsTip:
+        'Scarica gli allegati come documenti separati durante la sincronizzazione.',
+      jiraAttachmentSizeTip:
+        'Gli allegati più grandi di questo numero di byte saranno saltati.',
+      jiraLabelsTip:
+        'Etichette che dovrebbero essere saltate durante l\'indicizzazione (separate da virgola).',
+      jiraBlacklistTip:
+        'I commenti la cui email autore corrisponde a queste voci saranno ignorati.',
+      jiraScopedTokenTip:
+        'Abilita questo quando usi token Atlassian limitati (api.atlassian.com).',
+      jiraEmailTip: 'Email associata all\'account/token API Jira.',
+      jiraTokenTip:
+        'Token API generato da https://id.atlassian.com/manage-profile/security/api-tokens.',
+      jiraPasswordTip:
+        'Password opzionale per ambienti Jira Server/Data Center.',
+      mysqlDescription:
+        'Connettiti al database MySQL per sincronizzare i dati dalle tabelle usando query SQL.',
+      mysqlQueryTip:
+        'Query SQL per estrarre i dati dal tuo database (es. SELECT * FROM products WHERE status = "active").',
+      mysqlContentColumnsTip:
+        'Nomi di colonna separati da virgola i cui valori saranno combinati come contenuto del documento per la vettorizzazione.',
+      mysqlMetadataColumnsTip:
+        'Nomi di colonna separati da virgola da memorizzare come metadati del documento (non vettorizzati, ma ricercabili).',
+      mysqlIdColumnTip:
+        'Colonna da usare come ID documento univoco. Se non specificata, sarà usato un hash del contenuto.',
+      mysqlTimestampColumnTip:
+        'Colonna datetime/timestamp per la sincronizzazione incrementale. Saranno recuperate solo le righe modificate dopo l\'ultima sincronizzazione.',
+      postgresqlDescription:
+        'Connettiti al database PostgreSQL per sincronizzare i dati dalle tabelle usando query SQL.',
+      postgresqlQueryTip:
+        "Query SQL per estrarre i dati dal tuo database (es. SELECT * FROM products WHERE status = 'active').",
+      postgresqlContentColumnsTip:
+        'Nomi di colonna separati da virgola i cui valori saranno combinati come contenuto del documento per la vettorizzazione.',
+      postgresqlMetadataColumnsTip:
+        'Nomi di colonna separati da virgola da memorizzare come metadati del documento (non vettorizzati, ma ricercabili).',
+      postgresqlIdColumnTip:
+        'Colonna da usare come ID documento univoco. Se non specificata, sarà usato un hash del contenuto.',
+      postgresqlTimestampColumnTip:
+        'Colonna datetime/timestamp per la sincronizzazione incrementale. Saranno recuperate solo le righe modificate dopo l\'ultima sincronizzazione.',
+      rest_apiDescription:
+        'Connetti qualsiasi endpoint REST API come fonte dati usando un connettore flessibile guidato dalla configurazione.',
+      onedriveDescription:
+        'Connetti OneDrive o OneDrive for Business per indicizzare file e cartelle tramite query delta Microsoft Graph.',
+      onedriveTenantIdTip:
+        'ID tenant Azure Active Directory (Directory ID) dell\'organizzazione Microsoft 365.',
+      onedriveClientIdTip:
+        'ID applicazione (client) della registrazione app Azure AD con permesso Files.Read.All.',
+      onedriveClientSecretTip:
+        'Valore del client secret generato nella registrazione app Azure AD.',
+      onedriveFolderPathTip:
+        'Percorso sotto-cartella opzionale per limitare l\'indicizzazione (es. /Documents/Reports). Lascia vuoto per indicizzare l\'intero drive.',
+      outlookDescription:
+        'Connetti le caselle Outlook / Microsoft 365 e indicizza i messaggi tramite query delta Microsoft Graph.',
+      outlookTenantIdTip:
+        'ID tenant Azure Active Directory (Directory ID) dell\'organizzazione Microsoft 365.',
+      outlookClientIdTip:
+        'ID applicazione (client) della registrazione app Azure AD con permesso Mail.Read.',
+      outlookClientSecretTip:
+        'Valore del client secret generato nella registrazione app Azure AD.',
+      outlookFolderTip:
+        'Cartella di posta da sincronizzare (es. inbox, sentitems, archive). Predefinito inbox.',
+      outlookUserIdsTip:
+        'UPN o object ID separati da virgola delle caselle da sincronizzare. Lascia vuoto per sincronizzare ogni casella nel tenant (richiede User.Read.All).',
+      salesforceDescription:
+        'Connetti un\'org Salesforce e indicizza i record CRM (Account, Contatti, Opportunità, Casi, articoli Knowledge) tramite SOQL con sincronizzazione incrementale.',
+      salesforceInstanceUrlTip:
+        'URL org Salesforce, es. https://your-domain.my.salesforce.com (senza barra finale).',
+      salesforceClientIdTip:
+        'Consumer Key di una Connected App con Client Credentials Flow abilitato e lo scope api.',
+      salesforceClientSecretTip:
+        'Consumer Secret della Connected App usata per l\'autenticazione client-credentials.',
+      salesforceObjectsTip:
+        'Nomi API SObject separati da virgola da indicizzare. Predefinito Account, Contact, Opportunity, Case, Knowledge__kav.',
+      salesforceApiVersionTip:
+        'Versione REST API Salesforce (es. v59.0). Usa la versione che la tua org supporta.',
+      azure_blobDescription:
+        'Indicizza i blob da un container Azure Blob Storage in una knowledge base. Supporta autenticazione con account-key, connection-string e SAS-token. I blob invariati vengono saltati tramite fingerprinting ETag.',
+      azureBlobAuthModeTip:
+        'Scegli il metodo di autenticazione. Account Key e Connection String richiedono container_name; SAS Token richiede container_url + sas_token.',
+      azureBlobAccountNameTip:
+        'Nome account di storage Azure (es. mystorageaccount). Richiesto per l\'autenticazione account-key.',
+      azureBlobAccountKeyTip:
+        'Chiave di accesso account di storage (codificata Base64). Richiesta per l\'autenticazione account-key.',
+      azureBlobConnectionStringTip:
+        'Stringa di connessione Azure Storage completa (DefaultEndpointsProtocol=https;AccountName=...;...). Richiesta per l\'autenticazione connection-string.',
+      azureBlobContainerUrlTip:
+        'URL HTTPS completo del container (es. https://account.blob.core.windows.net/container). Richiesto per l\'autenticazione SAS-token.',
+      azureBlobSasTokenTip:
+        'Stringa di query SAS (senza il "?" iniziale). Richiesta per l\'autenticazione SAS-token.',
+      azureBlobContainerNameTip:
+        'Nome del container da indicizzare. Richiesto per l\'autenticazione account-key e connection-string.',
+      azureBlobPrefixTip:
+        'Prefisso nome blob opzionale per limitare l\'indicizzazione a una cartella virtuale (es. documents/reports/). Lascia vuoto per indicizzare l\'intero container.',
+      restApiQueryParamsTip:
+        'Coppie Chiave=valore (una per riga) inviate come parametri di query URL. Usa questo invece di incorporare i parametri nell\'URL.',
+      restApiHeadersTip:
+        'Oggetto JSON opzionale di header HTTP aggiuntivi da inviare con ogni richiesta.',
+      restApiItemsPathTip:
+        'Nome del campo o JSONPath all\'array di elementi nella risposta. Lascia vuoto per il rilevamento automatico (prova "items", "results", "data", ecc.).',
+      restApiIdFieldTip:
+        'Percorso del campo all\'interno di ogni elemento usato per costruire un ID documento stabile. Lascia vuoto per generare automaticamente dall\'hash del contenuto.',
+      restApiContentFieldsTip:
+        'Elenco separato da virgola di campi degli elementi da concatenare nel contenuto del documento.',
+      restApiMetadataFieldsTip:
+        'Elenco separato da virgola di campi degli elementi da memorizzare come metadati.',
+      restApiNextCursorPathTip:
+        'Espressione JSONPath che si risolve nel cursore della pagina successiva nella risposta API.',
+      restApiPollTimestampFieldTip:
+        'Percorso del campo in ogni elemento che rappresenta l\'ora dell\'ultimo aggiornamento, usato per la sincronizzazione incrementale.',
+      restApiRequestBodyTip:
+        'Body JSON opzionale da inviare per le richieste POST. Usato insieme ai parametri di query e alla paginazione.',
+      restApiRequestDelayTip:
+        'Ritardo in secondi tra richieste di pagina consecutive. Aiuta a evitare il rate limiting dall\'API. Imposta a 0 per disabilitare.',
+      restApiValidationApiKeyRequired:
+        'La chiave API è richiesta quando il tipo di autenticazione è API Key (Header).',
+      restApiValidationApiKeyHeaderNameRequired:
+        'Il nome header della chiave API è richiesto quando il tipo di autenticazione è API Key (Header).',
+      restApiValidationBearerTokenRequired:
+        'Il bearer token è richiesto quando il tipo di autenticazione è Bearer Token.',
+      restApiValidationBasicUsernameRequired:
+        'Il nome utente è richiesto quando il tipo di autenticazione è Basic Auth.',
+      restApiValidationBasicPasswordRequired:
+        'La password è richiesta quando il tipo di autenticazione è Basic Auth.',
+      restApiTestConnection: 'Testa connessione',
+      restApiTestSuccess: 'Connettore REST API validato con successo.',
+      restApiTestFailed:
+        'Validazione del connettore REST API fallita. Controlla la tua configurazione e i log.',
+      availableSourcesDescription: 'Seleziona una fonte dati da aggiungere',
+      availableSources: 'Fonti disponibili',
+      datasourceDescription: 'Gestisci la tua fonte dati e le connessioni',
       save: 'Salva',
       search: 'Cerca',
       availableModels: 'Modelli disponibili',
@@ -723,7 +1480,7 @@ Quanto sopra è il contenuto che devi riassumere.`,
       profileDescription: 'Aggiorna la tua foto e i dettagli personali qui.',
       maxTokens: 'Token massimi',
       maxTokensMessage: 'Token massimi richiesti',
-      maxTokensTip: `La dimensione massima del contesto dell'modello; un valore non valido o errato causerà un errore. Valore predefinito 512.`,
+      maxTokensTip: `La dimensione massima del contesto del modello; un valore non valido o errato causerà un errore. Valore predefinito 512.`,
       maxTokensInvalidMessage: 'Inserisci un numero valido per Token massimi.',
       maxTokensMinMessage: 'Token massimi non può essere inferiore a 0.',
       password: 'Password',
@@ -749,8 +1506,7 @@ Quanto sopra è il contenuto che devi riassumere.`,
       timezoneMessage: 'Inserisci il tuo fuso orario!',
       timezonePlaceholder: 'seleziona il tuo fuso orario',
       email: 'Email',
-      emailDescription:
-        "Una volta registrata, l'email non può essere cambiata.",
+      emailDescription: "Una volta registrata, l'email non può essere cambiata.",
       currentPassword: 'Password attuale',
       currentPasswordMessage: 'Inserisci la tua password!',
       newPassword: 'Nuova password',
@@ -761,7 +1517,7 @@ Quanto sopra è il contenuto che devi riassumere.`,
       confirmPassword: 'Conferma nuova password',
       confirmPasswordMessage: 'Conferma la tua password!',
       confirmPasswordNonMatchMessage:
-        'Le nuove password inserite non corrispondono!',
+        'La nuova password inserita non corrisponde!',
       cancel: 'Annulla',
       addedModels: 'Modelli aggiunti',
       modelsToBeAdded: 'Modelli da aggiungere',
@@ -775,31 +1531,42 @@ Quanto sopra è il contenuto che devi riassumere.`,
       baseUrl: 'URL Base',
       baseUrlTip:
         'Se la tua chiave API è da OpenAI, ignoralo. Qualsiasi altro fornitore intermedio fornirà questo URL base con la chiave API.',
+      tongyiBaseUrlTip:
+        'Per utenti cinesi, non è necessario compilare o usare https://dashscope.aliyuncs.com/compatible-mode/v1. Per utenti internazionali, usa https://dashscope-intl.aliyuncs.com/compatible-mode/v1',
       siliconBaseUrlTip:
-        'For Chinese users, no need to fill in or use https://api.siliconflow.cn/v1. For international users, use https://api.siliconflow.com/v1',
+        'Per utenti cinesi, non è necessario compilare o usare https://api.siliconflow.cn/v1. Per utenti internazionali, usa https://api.siliconflow.com/v1',
+      tongyiBaseUrlPlaceholder: '(Solo utenti internazionali, vedi suggerimento)',
+      minimaxBaseUrlTip:
+        'Solo utenti internazionali: usa https://api.minimax.io/v1',
+      minimaxBaseUrlPlaceholder:
+        '(Solo utenti internazionali, inserisci https://api.minimax.io/v1)',
       modify: 'Modifica',
       systemModelSettings: 'Imposta modelli predefiniti',
       chatModel: 'LLM',
-      chatModelTip:
-        'Il LLM predefinito per ogni nuova base di conoscenza creata.',
+      chatModelTip: 'Il LLM predefinito per ogni nuovo dataset creato.',
       embeddingModel: 'Embedding',
       embeddingModelTip:
-        'Il modello di embedding predefinito per ogni nuova base di conoscenza creata.',
+        'Il modello di embedding predefinito per ogni nuovo dataset creato. Se non riesci a trovare un modello di embedding dal menu a discesa, controlla se stai usando la versione slim di RAGFlow (che non include modelli di embedding) o controlla https://ragflow.io/docs/dev/supported_models per vedere se il tuo fornitore di modelli supporta questo modello.',
       img2txtModel: 'VLM',
       img2txtModelTip:
-        "Il VLM predefinito per ogni nuova base di conoscenza creata. Descrive un'immagine o un video.",
+        'Il VLM predefinito per ogni nuovo dataset creato. Descrive un\'immagine o un video. Se non riesci a trovare un modello dal menu a discesa, controlla https://ragflow.io/docs/dev/supported_models per vedere se il tuo fornitore di modelli supporta questo modello.',
       sequence2txtModel: 'ASR',
       sequence2txtModelTip:
-        'Il modello ASR predefinito per ogni nuova base di conoscenza creata. Usa questo modello per tradurre le voci in testo corrispondente.',
+        'Il modello ASR predefinito per ogni nuovo dataset creato. Usa questo modello per tradurre le voci in testo corrispondente.',
       rerankModel: 'Rerank',
-      rerankModelTip: `Il modello rerank predefinito per il reranking dei chunk.`,
+      rerankModelTip: `Il modello rerank predefinito per il reranking dei chunk. Se non riesci a trovare un modello dal menu a discesa, controlla https://ragflow.io/docs/dev/supported_models per vedere se il tuo fornitore di modelli supporta questo modello.`,
       ttsModel: 'TTS',
-      ttsModelTip: 'Il modello text-to-speech predefinito.',
+      ttsModelTip:
+        'Il modello text-to-speech predefinito. Se non riesci a trovare un modello dal menu a discesa, controlla https://ragflow.io/docs/dev/supported_models per vedere se il tuo fornitore di modelli supporta questo modello.',
       workspace: 'workspace',
       upgrade: 'Aggiorna',
       addLlmTitle: 'Aggiungi LLM',
       editLlmTitle: 'Modifica modello {{name}}',
       editModel: 'Modifica modello',
+      instanceName: 'Nome istanza',
+      instanceNameMessage: 'Inserisci il nome dell\'istanza!',
+      instanceNameTip:
+        'Un nome univoco per identificare questa istanza del fornitore sotto la stessa factory.',
       modelName: 'Nome modello',
       modelID: 'ID Modello',
       modelUid: 'UID Modello',
@@ -813,17 +1580,99 @@ Quanto sopra è il contenuto che devi riassumere.`,
         apiUrlPlaceholder:
           'Ad esempio: https://paddleocr-server.com/layout-parsing',
         accessToken: 'Token di accesso AI Studio',
-        accessTokenPlaceholder: 'Il tuo token AI Studio (facoltativo)',
+        accessTokenPlaceholder: 'Il tuo token AI Studio (opzionale)',
         algorithm: 'Algoritmo PaddleOCR',
         selectAlgorithm: 'Seleziona algoritmo',
         modelNamePlaceholder: 'Ad esempio: paddleocr-from-env-1',
         modelNameRequired: 'Il nome del modello è obbligatorio',
-        apiUrlRequired: 'L’URL API di PaddleOCR è obbligatorio',
+        apiUrlRequired: 'L\'URL API di PaddleOCR è obbligatorio',
       },
       vision: 'Supporta Vision?',
       ollamaLink: 'Come integrare {{name}}',
       FishAudioLink: 'Come usare FishAudio',
       TencentCloudLink: 'Come usare TencentCloud ASR',
+      volcModelNameMessage: 'Inserisci il nome del tuo modello!',
+      addEndpointID: 'ID Modello',
+      endpointIDMessage: 'Inserisci l\'ID del tuo modello',
+      addArkApiKey: 'VOLC ARK_API_KEY',
+      ArkApiKeyMessage: 'Inserisci la tua ARK_API_KEY',
+      bedrockModelNameMessage: 'Inserisci il nome del tuo modello!',
+      addBedrockEngineAK: 'ACCESS KEY',
+      bedrockAKMessage: 'Inserisci la tua ACCESS KEY',
+      addBedrockSK: 'SECRET KEY',
+      bedrockSKMessage: 'Inserisci la tua SECRET KEY',
+      bedrockRegion: 'Regione AWS',
+      bedrockRegionMessage: 'Seleziona!',
+      'us-east-2': 'US East (Ohio)',
+      'us-east-1': 'US East (N. Virginia)',
+      'us-west-1': 'US West (N. California)',
+      'us-west-2': 'US West (Oregon)',
+      'af-south-1': 'Africa (Cape Town)',
+      'ap-east-1': 'Asia Pacific (Hong Kong)',
+      'ap-south-2': 'Asia Pacific (Hyderabad)',
+      'ap-southeast-3': 'Asia Pacific (Jakarta)',
+      'ap-southeast-5': 'Asia Pacific (Malaysia)',
+      'ap-southeast-4': 'Asia Pacific (Melbourne)',
+      'ap-south-1': 'Asia Pacific (Mumbai)',
+      'ap-northeast-3': 'Asia Pacific (Osaka)',
+      'ap-northeast-2': 'Asia Pacific (Seoul)',
+      'ap-southeast-1': 'Asia Pacific (Singapore)',
+      'ap-southeast-2': 'Asia Pacific (Sydney)',
+      'ap-east-2': 'Asia Pacific (Taipei)',
+      'ap-southeast-7': 'Asia Pacific (Thailand)',
+      'ap-northeast-1': 'Asia Pacific (Tokyo)',
+      'ca-central-1': 'Canada (Central)',
+      'ca-west-1': 'Canada West (Calgary)',
+      'eu-central-1': 'Europe (Frankfurt)',
+      'eu-west-1': 'Europe (Ireland)',
+      'eu-west-2': 'Europe (London)',
+      'eu-south-1': 'Europe (Milan)',
+      'eu-west-3': 'Europe (Paris)',
+      'eu-south-2': 'Europe (Spain)',
+      'eu-north-1': 'Europe (Stockholm)',
+      'eu-central-2': 'Europe (Zurich)',
+      'il-central-1': 'Israel (Tel Aviv)',
+      'mx-central-1': 'Mexico (Central)',
+      'me-south-1': 'Middle East (Bahrain)',
+      'me-central-1': 'Middle East (UAE)',
+      'sa-east-1': 'South America (São Paulo)',
+      'us-gov-east-1': 'AWS GovCloud (US-East)',
+      'us-gov-west-1': 'AWS GovCloud (US-West)',
+      addTencentCloudSID: 'TencentCloud Secret ID',
+      TencentCloudSIDMessage: 'Inserisci il tuo Secret ID',
+      addTencentCloudSK: 'TencentCloud Secret Key',
+      TencentCloudSKMessage: 'Inserisci la tua Secret Key',
+      SparkModelNameMessage: 'Seleziona il modello Spark',
+      addSparkAPIPassword: 'Spark APIPassword',
+      SparkAPIPasswordMessage: 'inserisci la tua APIPassword',
+      addSparkAPPID: 'Spark APP ID',
+      SparkAPPIDMessage: 'inserisci il tuo APP ID',
+      addSparkAPISecret: 'Spark APISecret',
+      SparkAPISecretMessage: 'inserisci il tuo APISecret',
+      addSparkAPIKey: 'Spark APIKey',
+      SparkAPIKeyMessage: 'inserisci la tua APIKey',
+      yiyanModelNameMessage: 'Inserisci il nome del modello',
+      addyiyanAK: 'yiyan API KEY',
+      yiyanAKMessage: 'Inserisci la tua API KEY',
+      addyiyanSK: 'yiyan Secret KEY',
+      yiyanSKMessage: 'Inserisci la tua Secret KEY',
+      FishAudioModelNameMessage:
+        'Dai un nome al tuo modello di sintesi vocale',
+      addFishAudioAK: 'Fish Audio API KEY',
+      addFishAudioAKMessage: 'Inserisci la tua API KEY',
+      addFishAudioRefID: 'FishAudio Reference ID',
+      addFishAudioRefIDMessage:
+        'Inserisci il Reference ID (lascia vuoto per usare il modello predefinito).',
+      GoogleModelIDMessage: 'Inserisci il tuo model ID!',
+      addGoogleProjectID: 'Project ID',
+      GoogleProjectIDMessage: 'Inserisci il tuo Project ID',
+      addGoogleServiceAccountKey:
+        'Service Account Key (lascia vuoto se usi Application Default Credentials)',
+      GoogleServiceAccountKeyMessage:
+        'Inserisci la Google Cloud Service Account Key in formato base64',
+      addGoogleRegion: 'Google Cloud Region',
+      GoogleRegionMessage: 'Inserisci la Google Cloud Region',
+      modelProvidersWarn: `Aggiungi prima sia il modello di embedding che l'LLM in <b>Impostazioni > Fornitori di modelli</b>. Poi, impostali in 'Imposta modelli predefiniti'.`,
       apiVersion: 'Versione API',
       apiVersionMessage: 'Inserisci la versione API',
       add: 'Aggiungi',
@@ -843,10 +1692,47 @@ Quanto sopra è il contenuto che devi riassumere.`,
       publicKeyMessage: 'Inserisci la chiave pubblica',
       hostMessage: "Inserisci l'host",
       configuration: 'Configurazione',
+      langfuseDescription:
+        'Tracce, valutazioni, gestione dei prompt e metriche per il debug e il miglioramento della tua applicazione LLM.',
+      viewLangfuseSDocumentation: "Visualizza la documentazione di Langfuse",
       view: 'Visualizza',
+      modelsToBeAddedTooltip:
+        'Se il tuo fornitore di modelli non è elencato ma dichiara di essere "OpenAI-compatible", seleziona la scheda OpenAI-API-compatible per aggiungere i modelli pertinenti. ',
       mcp: 'MCP',
-      dingtalkAITableDescription:
-        'Connettiti a Dingtalk AI Table e sincronizza i record da una tabella specificata.',
+      mineru: {
+        modelNameRequired: 'Il nome del modello è obbligatorio',
+        apiServerRequired: 'La configurazione del MinerU API Server è richiesta',
+        serverUrlBackendLimit:
+          'L\'indirizzo URL del MinerU Server è disponibile solo per il backend client HTTP',
+        apiserver: 'Configurazione MinerU API Server',
+        outputDir: 'Percorso directory di output MinerU',
+        backend: 'Tipo di backend di elaborazione MinerU',
+        serverUrl: 'Indirizzo URL MinerU Server',
+        deleteOutput: 'Elimina i file di output dopo l\'elaborazione',
+        selectBackend: 'Seleziona backend di elaborazione',
+        backendOptions: {
+          pipeline: 'Elaborazione pipeline standard',
+          vlmTransformers: 'Vision Language Model con Transformers',
+          vlmVllmEngine: 'Vision Language Model con vLLM Engine',
+          vlmHttpClient: 'Vision Language Model via HTTP Client',
+          vlmMlxEngine: 'Vision Language Model con MLX Engine',
+          vlmVllmAsyncEngine:
+            'Vision Language Model con vLLM Async Engine (Sperimentale)',
+          vlmLmdeployEngine:
+            'Vision Language Model con LMDeploy Engine (Sperimentale)',
+        },
+      },
+      modelTypes: {
+        chat: 'Chat',
+        embedding: 'Embedding',
+        rerank: 'Rerank',
+        sequence2text: 'sequence2text',
+        tts: 'TTS',
+        image2text: 'OCR',
+        speech2text: 'ASR',
+      },
+      showToc: 'Mostra contenuto',
+      hideToc: 'Nascondi contenuto',
     },
     message: {
       registered: 'Registrato!',
@@ -880,10 +1766,12 @@ Quanto sopra è il contenuto che devi riassumere.`,
       requestError: 'Errore richiesta',
       networkAnomalyDescription:
         "C'è un'anomalia nella tua rete e non puoi connetterti al server.",
-      networkAnomaly: 'Anomalia di rete',
+      networkAnomaly: 'anomalia di rete',
       hint: 'suggerimento',
     },
     fileManager: {
+      uploadFolderTitle: 'Carica cartella',
+      folder: 'Cartella',
       files: 'File',
       name: 'Nome',
       uploadDate: 'Data caricamento',
@@ -899,7 +1787,7 @@ Quanto sopra è il contenuto che devi riassumere.`,
       directory: 'Directory',
       uploadTitle: 'Trascina e rilascia il tuo file qui per caricarlo',
       uploadDescription:
-        'Supporta caricamento singolo o multiplo. Limite dimensione file totale per caricamento: 1GB, con limite batch di 32 file.',
+        'Supporta caricamento singolo o multiplo. Per un RAGFlow distribuito localmente: il limite di dimensione totale dei file per caricamento è 1GB, con un limite batch di 32 file. Non c\'è limite al numero totale di file per account. Per cloud.ragflow.io, il limite di dimensione totale dei file per caricamento è 10MB, con ogni file non superiore a 10MB e un massimo di 128 file per account.',
       local: 'Caricamenti locali',
       s3: 'Caricamenti S3',
       preview: 'Anteprima',
@@ -910,19 +1798,175 @@ Quanto sopra è il contenuto che devi riassumere.`,
       pleaseUploadAtLeastOneFile: 'Carica almeno un file',
     },
     flow: {
+      preprocess: {
+        preprocess: 'Pre-elaborazione',
+        mainContent: 'Contenuto principale',
+        abstract: 'Abstract',
+        author: 'Autore',
+        sectionTitle: 'Titolo sezione',
+      },
+      editTags: 'Modifica tag',
+      editTagsDescription:
+        'Aggiungi tag per organizzare e filtrare i tuoi agenti. Premi Invio o virgola per aggiungere.',
+      tagsPlaceholder: 'Aggiungi un tag e premi Invio',
+      tagSuggestionsLabel: 'Tag esistenti',
+      removeTagAriaLabel: 'Rimuovi {{tag}}',
+      includeHeadingContent: 'Separa contenuto intestazione padre',
+      includeHeadingContentTip:
+        'Quando abilitato, i chunk includono solo il loro percorso di intestazione e contenuto; il contenuto immediatamente successivo a un\'intestazione padre è mantenuto come chunk separato.',
+      rootAsHeading: 'Imposta il primo chunk come contesto globale',
+      rootAsHeadingTip:
+        'Tratta la prima divisione come intestazione globale per mantenere un contesto coerente nella gerarchia del documento. Ideale per i curriculum dove la prima sezione identifica il soggetto.',
+      hierarchyTip: `Costruisci un albero di intestazioni e produci chunk autosufficienti, ciascuno con il suo intero percorso ancestrale (es. Parte 1 › Capitolo 3 › Sezione 2 + testo del corpo).\n
+Ideale per: testi altamente strutturati — come statuti legali, regolamenti, contratti e specifiche tecniche — dove ogni chunk deve essere identificabile dalla sua posizione nella gerarchia.`,
+      groupTip: `Dividi il documento in modo piatto a un livello di intestazione scelto, unendo sezioni piccole adiacenti per garantire il flusso semantico. I chunk escludono il percorso ancestrale.\n
+Ideale per: documenti con contenuto fluente e contestualmente connesso — come libri, manuali, report e articoli — dove la coerenza narrativa dipende dal mantenere insieme i paragrafi adiacenti.`,
+      enableMultiColumn: 'Rileva layout multi-colonna',
+      enableMultiColumnTip:
+        'Rileva e analizza i layout di pagina multi-colonna per preservare il corretto ordine di lettura. Attiva questo per PDF o documenti con layout a due colonne o stile giornale.',
+      removeToc: 'Rimuovi indice originale',
+      removeTocTip:
+        'Rimuove l\'indice incluso nel PDF originale, così non viene analizzato come contenuto regolare o suddiviso per il recupero.',
+      removeHeaderFooter: 'Rimuovi intestazione e piè di pagina',
       autoPlay: 'Riproduzione automatica audio',
+      downloadFileTypeTip: 'Il tipo di file da scaricare',
+      downloadFileType: 'Tipo di file da scaricare',
+      formatTypeError: 'Errore di formato o tipo',
+      variableNameMessage:
+        'Il nome della variabile può contenere solo lettere, underscore e numeri',
+      variableDescription: 'Descrizione variabile',
+      defaultValue: 'Valore predefinito',
+      conversationVariable: 'Variabile di conversazione',
+      recommended: 'Consigliato',
+      customerSupport: 'Supporto clienti',
+      marketing: 'Marketing',
+      consumerApp: 'App consumer',
+      other: 'Altro',
+      ingestionPipeline: 'Ingestion pipeline',
+      agents: 'Agenti',
+      publishedAt: 'Pubblicato il',
+      days: 'Giorni',
+      beginInput: 'Input iniziale',
+      ref: 'Variabile',
+      stockCode: 'Codice azione',
+      apiKeyPlaceholder:
+        'YOUR_API_KEY (ottenuta da https://serpapi.com/manage-api-key)',
+      flowStart: 'Inizio',
+      flowNum: 'N',
+      test: 'Test',
+      extractDepth: 'Profondità estrazione',
+      format: 'Formato',
+      basic: 'base',
+      advanced: 'avanzato',
+      general: 'generale',
+      searchDepth: 'Profondità ricerca',
+      tavilyTopic: 'Argomento Tavily',
+      maxResults: 'Risultati massimi',
+      includeAnswer: 'Includi risposta',
+      includeRawContent: 'Includi contenuto grezzo',
+      includeImages: 'Includi immagini',
+      includeImageDescriptions: 'Includi descrizioni immagini',
+      includeDomains: 'Includi domini',
+      ExcludeDomains: 'Escludi domini',
+      Days: 'Giorni',
+      comma: 'Virgola',
+      semicolon: 'Punto e virgola',
+      period: 'Punto',
+      lineBreak: 'Interruzione di riga',
+      tab: 'Tab',
+      space: 'Spazio',
+      delimiters: 'Delimitatori',
+      one: 'Uno',
+      oneChunkTitle: 'Nota',
+      oneChunkDescription:
+        'Tutte le sezioni analizzate saranno unite in ordine in un singolo chunk.',
+      flattenMediaToText: 'Disabilita modello visivo',
+      flattenMediaToTextTip:
+        'Tratta le sezioni di immagini e tabelle come testo semplice e salta il miglioramento visivo.',
+      enableChildrenDelimiters: 'I chunk figli sono usati per il recupero',
+      merge: 'Unisci',
+      split: 'Dividi',
+      script: 'Script',
+      iterationItemDescription:
+        'Rappresenta l\'elemento corrente nell\'iterazione, che può essere referenziato e manipolato nei passaggi successivi.',
+      guidingQuestion: 'Domanda guida',
+      onFailure: 'In caso di fallimento',
+      userPromptDefaultValue:
+        'Questo è l\'ordine che devi inviare all\'agente.',
+      search: 'Cerca',
+      communication: 'Comunicazione',
+      developer: 'Sviluppatore',
+      typeCommandORsearch: 'Digita un comando o cerca...',
+      builtIn: 'Integrato',
+      ExceptionDefaultValue: 'Valore predefinito eccezione',
+      exceptionMethod: 'Metodo eccezione',
+      maxRounds: 'Round massimi di riflessione',
+      delayAfterError: 'Ritardo dopo errore',
+      maxRetries: 'Round massimi di ritentativo',
+      maxSteps: 'Passi massimi',
+      headless: 'Headless',
+      enableDefaultExtensions: 'Abilita estensioni predefinite',
+      enableDefaultExtensionsTip:
+        'Abilita le estensioni predefinite di browser-use (uBlock, gestione cookie, ClearURLs). Disabilita questo per evitare download di estensioni in runtime.',
+      chromiumSandbox: 'Sandbox Chromium',
+      chromiumSandboxTip:
+        'Se abilitare la sandbox Chromium. Negli ambienti Docker root questo è solitamente disabilitato; su host normali è consigliato abilitarlo.',
+      persistSession: 'Mantieni sessione',
+      persistSessionTip:
+        'Quando abilitato, questo nodo Browser riutilizza la sua sessione del browser per evitare accessi ripetuti.',
+      uploadSources: 'Carica sorgenti',
+      uploadSourcesTip:
+        'Supporta ID di file, URL di file o variabili. Puoi separare più valori con virgole o usare un formato array JSON (ad esempio ["id1","https://example.com/a.pdf"]).',
+      advancedSettings: 'Impostazioni avanzate',
+      addTools: 'Aggiungi strumenti',
+      sysPromptDefaultValue: `
+      <role>
+        Sei un assistente utile, un assistente IA specializzato nella risoluzione di problemi per l'utente.
+        Se viene fornito un dominio specifico, adatta la tua competenza a quel dominio; altrimenti, opera come generalista.
+      </role>
+      <instructions>
+        1. Comprendi la richiesta dell'utente.
+        2. Scomponila in sottoattività logiche.
+        3. Esegui ogni sottoattività passo dopo passo, ragionando in modo trasparente.
+        4. Verifica accuratezza e coerenza.
+        5. Riassumi il risultato finale in modo chiaro.
+      </instructions>`,
+      singleLineText: 'Testo a riga singola',
+      multimodalModels: 'Modelli multimodali',
+      textOnlyModels: 'Modelli solo testo',
+      allModels: 'Tutti i modelli',
+      codeExecDescription: 'Scrivi la tua logica Python o Javascript personalizzata.',
+      stringTransformDescription:
+        'Modifica il contenuto del testo. Attualmente supporta: divisione o concatenazione del testo.',
+      foundation: 'Fondamenti',
+      tools: 'Strumenti',
+      dataManipulation: 'Manipolazione dati',
+      flow: 'Flusso',
+      dialog: 'Dialogo',
+      cite: 'Cita',
+      citeTip: 'citeTip',
       name: 'Nome',
       nameMessage: 'Inserisci nome',
+      lastSavedAt: 'Ultimo salvataggio',
       description: 'Descrizione',
       descriptionMessage: 'Questo è un agente per un compito specifico.',
       examples: 'Esempi',
       to: 'A',
       msg: 'Messaggi',
+      msgTip:
+        'Restituisce il contenuto della variabile del componente a monte o il testo inserito da te.',
       messagePlaceholder: `Inserisci il contenuto del messaggio, usa '/' per inserire rapidamente variabili.`,
       messageMsg: 'Inserisci messaggio o elimina questo campo.',
       addField: 'Aggiungi opzione',
       addMessage: 'Aggiungi messaggio',
       loop: 'Ciclo',
+      loopDescription:
+        'Il ciclo è il limite massimo del numero di cicli del componente corrente; quando il numero di cicli supera il valore del ciclo, significa che il componente non può completare l\'attività corrente, per favore ri-ottimizza l\'agente',
+      exitLoop: 'Esci dal ciclo',
+      exitLoopDescription: `Equivalente a "break". Questo nodo non ha elementi di configurazione. Quando il corpo del ciclo raggiunge questo nodo, il ciclo termina.`,
+      loopVariables: 'Variabili ciclo',
+      maximumLoopCount: 'Conteggio massimo cicli',
+      loopTerminationCondition: 'Condizione di terminazione ciclo',
       yes: 'Sì',
       no: 'No',
       key: 'Chiave',
@@ -934,16 +1978,16 @@ Quanto sopra è il contenuto che devi riassumere.`,
       title: 'ID:',
       beginDescription: 'Qui è dove inizia il flusso.',
       answerDescription: `Un componente che funge da interfaccia tra umano e bot, ricevendo input utente e visualizzando le risposte dell'agente.`,
-      retrievalDescription: `Un componente che recupera informazioni da basi di conoscenza specificate (dataset). Assicurati che le basi di conoscenza selezionate usino lo stesso modello di embedding.`,
+      retrievalDescription: `Un componente che recupera informazioni da dataset specificati (dataset). Assicurati che i dataset selezionati usino lo stesso modello di embedding.`,
       generateDescription: `Un componente che richiede al LLM di generare risposte. Assicurati che il prompt sia impostato correttamente.`,
-      categorizeDescription: `Un componente che usa il LLM per classificare gli input utente in categorie predefinite.`,
-      relevantDescription: `Un componente che usa il LLM per valutare se l'output a monte è rilevante per l'ultima query dell'utente.`,
+      categorizeDescription: `Un componente che usa il LLM per classificare gli input utente in categorie predefinite. Assicurati di specificare il nome, la descrizione e gli esempi per ogni categoria, insieme al componente successivo corrispondente.`,
+      relevantDescription: `Un componente che usa il LLM per valutare se l'output a monte è rilevante per l'ultima query dell'utente. Assicurati di specificare il componente successivo per ogni risultato di giudizio.`,
       rewriteQuestionDescription: `Un componente che riscrive una query utente dal componente Interact, basandosi sul contesto dei dialoghi precedenti.`,
       messageDescription:
-        "Questo componente restituisce l'output dati finale del workflow insieme al contenuto del messaggio predefinito.",
-      keywordDescription: `Un componente che recupera i primi N risultati di ricerca dall'input dell'utente.`,
-      switchDescription: `Un componente che valuta condizioni basate sull'output dei componenti precedenti e dirige il flusso di esecuzione di conseguenza.`,
-      wikipediaDescription: `Un componente che cerca da wikipedia.org, usando TopN per specificare il numero di risultati di ricerca.`,
+        "Questo componente restituisce l'output dati finale del workflow insieme al contenuto del messaggio predefinito. ",
+      keywordDescription: `Un componente che recupera i primi N risultati di ricerca dall'input dell'utente. Assicurati che il valore TopN sia impostato correttamente prima dell'uso.`,
+      switchDescription: `Un componente che valuta condizioni basate sull'output dei componenti precedenti e dirige il flusso di esecuzione di conseguenza. Permette logica di ramificazione complessa definendo casi e specificando azioni per ogni caso o azione predefinita se nessuna condizione è soddisfatta.`,
+      wikipediaDescription: `Un componente che cerca da wikipedia.org, usando TopN per specificare il numero di risultati di ricerca. Integra i dataset esistenti.`,
       promptText: `Per favore riassumi i seguenti paragrafi. Fai attenzione ai numeri, non inventare cose. Paragrafi come segue:
         {input}
   Quanto sopra è il contenuto che devi riassumere.`,
@@ -966,15 +2010,18 @@ Quanto sopra è il contenuto che devi riassumere.`,
       keywordExtract: 'Parola chiave',
       keywordExtractDescription: `Un componente che estrae parole chiave da una query utente, con Top N che specifica il numero di parole chiave da estrarre.`,
       baidu: 'Baidu',
-      baiduDescription: `Un componente che cerca da baidu.com, usando TopN per specificare il numero di risultati di ricerca.`,
+      baiduDescription: `Un componente che cerca da baidu.com, usando TopN per specificare il numero di risultati di ricerca. Integra i dataset esistenti.`,
       duckDuckGo: 'DuckDuckGo',
       duckDuckGoDescription:
-        'Un componente che cerca da duckduckgo.com, permettendo di specificare il numero di risultati di ricerca usando TopN.',
+        'Un componente che cerca da duckduckgo.com, permettendo di specificare il numero di risultati di ricerca usando TopN. Integra i dataset esistenti.',
       searXNG: 'SearXNG',
       searXNGDescription:
-        'Un componente che cerca tramite lURL dellistanza SearXNG fornita. Specifica TopN e lURL dellistanza.',
+        'Un componente che cerca tramite l\'URL dell\'istanza SearXNG fornita. Specifica TopN e l\'URL dell\'istanza.',
       docGenerator: 'Generatore Documenti',
-      docGeneratorDescription: `Genera file da contenuto Markdown.`,
+      docGeneratorDescription: `Genera un file da contenuto Markdown.`,
+      browser: 'Browser',
+      browserDescription:
+        'Automatizza attività del browser. Supporta la configurazione del modello e azioni guidate da prompt. Le sorgenti di caricamento supportano ID di file e URL, e i file scaricati possono essere salvati in una cartella di destinazione.',
       subtitle: 'Sottotitolo',
       logoImage: 'Immagine Logo',
       logoPosition: 'Posizione Logo',
@@ -998,30 +2045,37 @@ Quanto sopra è il contenuto che devi riassumere.`,
       news: 'Notizie',
       messageHistoryWindowSize: 'Dimensione finestra messaggi',
       messageHistoryWindowSizeTip:
-        'La dimensione della finestra della cronologia conversazione visibile al LLM.',
+        'La dimensione della finestra della cronologia conversazione visibile all\'LLM. Più grande è meglio, ma fai attenzione al limite massimo di token dell\'LLM.',
       wikipedia: 'Wikipedia',
       pubMed: 'PubMed',
       pubMedDescription:
-        'Un componente che cerca da https://pubmed.ncbi.nlm.nih.gov/.',
+        'Un componente che cerca da https://pubmed.ncbi.nlm.nih.gov/, permettendo di specificare il numero di risultati di ricerca usando TopN. Integra i dataset esistenti.',
       email: 'Email',
       emailTip:
         "L'email è un campo richiesto. Devi inserire un indirizzo email qui.",
       arXiv: 'ArXiv',
-      arXivDescription: 'Un componente che cerca da https://arxiv.org/.',
+      arXivDescription:
+        'Un componente che cerca da https://arxiv.org/, permettendo di specificare il numero di risultati di ricerca usando TopN. Integra i dataset esistenti.',
       sortBy: 'Ordina per',
       submittedDate: 'Data invio',
       lastUpdatedDate: 'Data ultimo aggiornamento',
       relevance: 'Rilevanza',
       google: 'Google',
-      googleDescription: 'Un componente che cerca da https://www.google.com/.',
+      googleDescription:
+        'Un componente che cerca da https://www.google.com/, permettendo di specificare il numero di risultati di ricerca usando TopN. Integra i dataset esistenti. Nota che questo richiede una chiave API da serpapi.com.',
       bing: 'Bing',
-      bingDescription: 'Un componente che cerca da https://www.bing.com/.',
+      bingDescription:
+        'Un componente che cerca da https://www.bing.com/, permettendo di specificare il numero di risultati di ricerca usando TopN. Integra i dataset esistenti. Nota che questo richiede una chiave API da microsoft.com.',
       apiKey: 'CHIAVE API',
       country: 'Paese e regione',
       language: 'Lingua',
       googleScholar: 'Google Scholar',
       googleScholarDescription:
-        'Un componente che cerca https://scholar.google.com/.',
+        'Un componente che cerca https://scholar.google.com/. Puoi usare Top N per specificare il numero di risultati di ricerca.',
+      yearLow: 'Anno minimo',
+      yearHigh: 'Anno massimo',
+      patents: 'Brevetti',
+      data: 'Dati',
       deepL: 'DeepL',
       deepLDescription:
         'Un componente che ottiene traduzioni più specializzate da https://www.deepl.com/.',
@@ -1030,7 +2084,120 @@ Quanto sopra è il contenuto che devi riassumere.`,
       targetLang: 'Lingua destinazione',
       gitHub: 'GitHub',
       gitHubDescription:
-        'Un componente che cerca repository da https://github.com/.',
+        'Un componente che cerca repository da https://github.com/. Puoi usare Top N per specificare il numero di risultati di ricerca.',
+      baiduFanyi: 'BaiduFanyi',
+      baiduFanyiDescription:
+        'Un componente che ottiene traduzioni specializzate da https://fanyi.baidu.com/.',
+      appid: 'App ID',
+      secretKey: 'Chiave segreta',
+      domain: 'Dominio',
+      transType: 'Tipo di traduzione',
+      baiduSecretKeyOptions: {
+        translate: 'Traduzione generale',
+        fieldtranslate: 'Traduzione di settore',
+      },
+      baiduDomainOptions: {
+        it: 'Tecnologia dell\'informazione',
+        finance: 'Finanza ed economia',
+        machinery: 'Produzione meccanica',
+        senimed: 'Biomedicina',
+        novel: 'Letteratura online',
+        academic: 'Paper accademico',
+        aerospace: 'Aerospaziale',
+        wiki: 'Scienze umane e sociali',
+        news: 'Notizie e informazioni',
+        law: 'Leggi e regolamenti',
+        contract: 'Contratto',
+      },
+      baiduSourceLangOptions: {
+        auto: 'Rilevamento automatico',
+        zh: 'Cinese',
+        en: 'Inglese',
+        yue: 'Cantonese',
+        wyw: 'Cinese classico',
+        jp: 'Giapponese',
+        kor: 'Coreano',
+        fra: 'Francese',
+        spa: 'Spagnolo',
+        th: 'Thailandese',
+        ara: 'Arabo',
+        ru: 'Russo',
+        pt: 'Portoghese',
+        de: 'Tedesco',
+        it: 'Italiano',
+        el: 'Greco',
+        nl: 'Olandese',
+        pl: 'Polacco',
+        bul: 'Bulgaro',
+        est: 'Estone',
+        dan: 'Danese',
+        fin: 'Finlandese',
+        cs: 'Ceco',
+        rom: 'Rumeno',
+        slo: 'Sloveno',
+        swe: 'Svedese',
+        hu: 'Ungherese',
+        cht: 'Cinese tradizionale',
+        vie: 'Vietnamita',
+      },
+      qWeather: 'QWeather',
+      qWeatherDescription:
+        'Un componente che recupera informazioni meteorologiche, come temperatura e qualità dell\'aria, da https://www.qweather.com/.',
+      lang: 'Lingua',
+      type: 'Tipo',
+      webApiKey: 'Web API key',
+      userType: 'Tipo utente',
+      timePeriod: 'Periodo di tempo',
+      qWeatherLangOptions: {
+        zh: 'Cinese semplificato',
+        'zh-hant': 'Cinese tradizionale',
+        en: 'Inglese',
+        de: 'Tedesco',
+        es: 'Spagnolo',
+        fr: 'Francese',
+        it: 'Italiano',
+        ja: 'Giapponese',
+        ko: 'Coreano',
+        ru: 'Russo',
+        hi: 'Hindi',
+        th: 'Thailandese',
+        ar: 'Arabo',
+        pt: 'Portoghese',
+        bn: 'Bengalese',
+        ms: 'Malese',
+        nl: 'Olandese',
+        el: 'Greco',
+        la: 'Latino',
+        sv: 'Svedese',
+        id: 'Indonesiano',
+        pl: 'Polacco',
+        tr: 'Turco',
+        cs: 'Ceco',
+        et: 'Estone',
+        vi: 'Vietnamita',
+        fil: 'Filippino',
+        fi: 'Finlandese',
+        he: 'Ebraico',
+        is: 'Islandese',
+        nb: 'Norvegese',
+      },
+      qWeatherTypeOptions: {
+        weather: 'Previsioni meteo',
+        indices: 'Indice vita meteo',
+        airquality: 'Qualità dell\'aria',
+      },
+      qWeatherUserTypeOptions: {
+        free: 'Abbonato gratuito',
+        paid: 'Abbonato a pagamento',
+      },
+      qWeatherTimePeriodOptions: {
+        now: 'Ora',
+        '3d': '3 giorni',
+        '7d': '7 giorni',
+        '10d': '10 giorni',
+        '15d': '12 giorni',
+        '30d': '30 giorni',
+      },
       publish: 'API',
       exeSQL: 'Esegui SQL',
       exeSQLDescription:
@@ -1038,24 +2205,134 @@ Quanto sopra è il contenuto che devi riassumere.`,
       dbType: 'Tipo database',
       database: 'Database',
       username: 'Nome utente',
+      userId: 'ID utente',
       host: 'Host',
       port: 'Porta',
       password: 'Password',
       switch: 'Switch',
       logicalOperator: 'Operatore logico',
+      switchOperatorOptions: {
+        equal: 'Uguale a',
+        notEqual: 'Diverso da',
+        gt: 'Maggiore di',
+        ge: 'Maggiore o uguale',
+        lt: 'Minore di',
+        le: 'Minore o uguale',
+        contains: 'Contiene',
+        notContains: 'Non contiene',
+        startWith: 'Inizia con',
+        endWith: 'Finisce con',
+        empty: 'È vuoto',
+        notEmpty: 'Non vuoto',
+        in: 'In',
+        notIn: 'Non in',
+        is: 'È',
+        isNot: 'Non è',
+      },
+      switchLogicOperatorOptions: {
+        and: 'AND',
+        or: 'OR',
+      },
       operator: 'Operatore',
       value: 'Valore',
       useTemplate: 'Usa',
+      wenCai: 'WenCai',
+      queryType: 'Tipo di query',
+      wenCaiDescription:
+        'Un componente che ottiene informazioni finanziarie, inclusi prezzi delle azioni e notizie sui finanziamenti, da un\'ampia gamma di siti web finanziari.',
+      wenCaiQueryTypeOptions: {
+        stock: 'azione',
+        zhishu: 'indice',
+        fund: 'fondo',
+        hkstock: 'Azioni Hong Kong',
+        usstock: 'Mercato azionario USA',
+        threeboard: 'New OTC market',
+        conbond: 'Obbligazione convertibile',
+        insurance: 'assicurazione',
+        futures: 'futures',
+        lccp: 'Finanziamento',
+        foreign_exchange: 'Valuta estera',
+      },
+      akShare: 'AkShare',
+      akShareDescription:
+        'Un componente che ottiene notizie sulle azioni da https://www.eastmoney.com/.',
+      yahooFinance: 'YahooFinance',
+      yahooFinanceDescription:
+        'Un componente che interroga informazioni su una società quotata in borsa usando il suo simbolo ticker.',
       crawler: 'Web crawler',
       crawlerDescription:
         'Un componente che estrae codice sorgente HTML da un URL specificato.',
       proxy: 'Proxy',
+      crawlerResultOptions: {
+        html: 'Html',
+        markdown: 'Markdown',
+        content: 'Contenuto',
+      },
       extractType: 'Tipo estrazione',
       info: 'Info',
       history: 'Cronologia',
+      financials: 'Dati finanziari',
+      balanceSheet: 'Stato patrimoniale',
+      cashFlowStatement: 'Rendiconto flussi di cassa',
+      jin10: 'Jin10',
+      jin10Description:
+        'Un componente che recupera informazioni finanziarie dalla piattaforma aperta Jin10, inclusi aggiornamenti di notizie, calendari, quotazioni e riferimenti.',
+      flashType: 'Tipo flash',
+      filter: 'Filtro',
+      contain: 'Contiene',
+      calendarType: 'Tipo calendario',
+      calendarDatashape: 'Forma dati calendario',
+      symbolsDatatype: 'Tipo dati simboli',
+      symbolsType: 'Tipo simboli',
+      jin10TypeOptions: {
+        flash: 'Notizie rapide',
+        calendar: 'Calendario',
+        symbols: 'quotazioni',
+        news: 'riferimento',
+      },
+      jin10FlashTypeOptions: {
+        '1': 'Notizie di mercato',
+        '2': 'Notizie futures',
+        '3': 'Notizie US-Hong Kong',
+        '4': 'Notizie A-Share',
+        '5': 'Notizie materie prime e forex',
+      },
+      jin10CalendarTypeOptions: {
+        cj: 'Calendario dati macroeconomici',
+        qh: 'Calendario futures',
+        hk: 'Calendario mercato azionario Hong Kong',
+        us: 'Calendario mercato azionario USA',
+      },
+      jin10CalendarDatashapeOptions: {
+        data: 'Dati',
+        event: 'Evento',
+        holiday: 'Festività',
+      },
+      jin10SymbolsTypeOptions: {
+        GOODS: 'Quotazioni materie prime',
+        FOREX: 'Quotazioni forex',
+        FUTURE: 'Quotazioni mercato internazionale',
+        CRYPTO: 'Quotazioni criptovalute',
+      },
+      jin10SymbolsDatatypeOptions: {
+        symbols: 'Lista materie prime',
+        quotes: 'Ultime quotazioni di mercato',
+      },
       concentrator: 'Concentratore',
       concentratorDescription:
         "Un componente che riceve l'output dal componente a monte e lo passa come input ai componenti a valle.",
+      tuShare: 'TuShare',
+      tuShareDescription:
+        'Un componente che ottiene brevi notizie finanziarie dai principali siti web finanziari, aiutando la ricerca di settore e quantitativa.',
+      tuShareSrcOptions: {
+        sina: 'Sina',
+        wallstreetcn: 'wallstreetcn',
+        '10jqka': 'Straight flush',
+        eastmoney: 'Eastmoney',
+        yuncaijing: 'YUNCAIJING',
+        fenghuang: 'FENGHUANG',
+        jinrongjie: 'JRJ',
+      },
       token: 'Token',
       src: 'Sorgente',
       startDate: 'Data inizio',
@@ -1073,6 +2350,8 @@ Quanto sopra è il contenuto che devi riassumere.`,
       cleanHtml: 'Pulisci HTML',
       cleanHtmlTip:
         'Se la risposta è formattata HTML e vuoi solo il contenuto primario, attivalo.',
+      invalidUrl:
+        'Deve essere un URL valido o un URL con placeholder di variabili nel formato {variable_name} o {component@variable}',
       reference: 'Riferimento',
       input: 'Input',
       output: 'Output',
@@ -1086,7 +2365,7 @@ Quanto sopra è il contenuto che devi riassumere.`,
       testRun: 'Test esecuzione',
       template: 'Template',
       templateDescription:
-        "Un componente che formatta l'output di altri componenti.",
+        'Un componente che formatta l\'output di altri componenti. 1. Supporta template Jinja2, prima converte l\'input in un oggetto e poi renderizza il template, 2. Mantiene contemporaneamente il metodo originale di sostituzione stringhe {parameter}',
       emailComponent: 'Email',
       emailDescription: "Invia un'email a un indirizzo specificato.",
       smtpServer: 'Host SMTP',
@@ -1099,12 +2378,40 @@ Quanto sopra è il contenuto che devi riassumere.`,
       ccEmail: 'Email CC',
       emailSubject: 'Oggetto',
       emailContent: 'Contenuto',
+      smtpServerRequired: 'Inserisci l\'indirizzo del server SMTP',
+      senderEmailRequired: 'Inserisci l\'email del mittente',
+      authCodeRequired: 'Inserisci il codice di autorizzazione',
+      toEmailRequired: 'Inserisci l\'email del destinatario',
+      emailContentRequired: 'Inserisci il contenuto dell\'email',
+      emailSentSuccess: 'Email inviata con successo',
+      emailSentFailed: 'Invio email fallito',
+      dynamicParameters: 'Parametri dinamici',
+      jsonFormatTip:
+        'Il componente a monte dovrebbe fornire una stringa JSON nel seguente formato:',
+      toEmailTip: 'to_email: Email destinatario (Richiesto)',
+      ccEmailTip: 'cc_email: Email CC (Opzionale)',
+      subjectTip: 'subject: Oggetto email (Opzionale)',
+      contentTip: 'content: Contenuto email (Opzionale)',
+      jsonUploadTypeErrorMessage: 'Carica un file json',
+      jsonUploadContentErrorMessage: 'errore file json',
       iteration: 'Iterazione',
       iterationDescription: `Un componente di loop che itera su un array di input ed esegue una logica definita per ogni elemento.`,
+      delimiterTip: `
+Questo delimitatore è usato per dividere il testo di input in diversi pezzi di testo, ognuno dei quali sarà eseguito come elemento di input di ogni iterazione.`,
+      delimiterOptions: {
+        comma: 'Virgola',
+        lineBreak: 'Interruzione di riga',
+        tab: 'Tab',
+        underline: 'Underscore',
+        diagonal: 'Barra in avanti',
+        minus: 'Trattino',
+        semicolon: 'Punto e virgola',
+      },
       addVariable: 'Aggiungi variabile',
       variableSettings: 'Impostazioni variabili',
       systemPrompt: 'Prompt di sistema',
       userPrompt: 'Prompt utente',
+      tocDataSource: 'Fonte dati',
       addCategory: 'Aggiungi categoria',
       categoryName: 'Nome categoria',
       nextStep: 'Passo successivo',
@@ -1112,6 +2419,25 @@ Quanto sopra è il contenuto che devi riassumere.`,
         'Estrai informazioni utente in variabile globale durante la conversazione',
       variableExtract: 'Variabili',
       variables: 'Variabili',
+      variablesTip: `Imposta la variabile chiave json chiara con un valore vuoto. es.
+      {
+        "UserCode":"",
+        "NumberPhone":""
+      }`,
+      datatype: 'Tipo MIME della richiesta HTTP',
+      insertVariableTip: `Premi / per inserire variabili`,
+      mergePath: 'Unisci percorso',
+      mergePathTip:
+        'Quando abilitato, un suffisso con punto immediatamente dopo una variabile viene unito in una query di percorso, come {node@result.name}.',
+      historyVersion: 'Cronologia versioni',
+      version: {
+        created: 'Creato',
+        details: 'Dettagli versione',
+        dsl: 'DSL',
+        download: 'Scarica',
+        version: 'Versione',
+        select: 'Nessuna versione selezionata',
+      },
       setting: 'Impostazioni',
       settings: {
         agentSetting: 'Impostazioni agente',
@@ -1126,22 +2452,356 @@ Quanto sopra è il contenuto che devi riassumere.`,
       },
       noMoreData: 'Nessun altro dato',
       searchAgentPlaceholder: 'Cerca agente',
+      footer: {
+        profile: 'All rights reserved @ React',
+      },
+      layout: {
+        file: 'file',
+        knowledge: 'conoscenza',
+        chat: 'chat',
+      },
       prompt: 'Prompt',
       promptTip:
-        'Usa il prompt di sistema per descrivere il compito per il LLM, specificare come dovrebbe rispondere e delineare altri requisiti.',
+        'Usa il prompt di sistema per descrivere il compito per l\'LLM, specificare come dovrebbe rispondere e delineare altri requisiti vari. Il prompt di sistema è spesso usato insieme a chiavi (variabili), che servono come vari input di dati per l\'LLM. Usa una barra `/` o il pulsante (x) per mostrare le chiavi da usare.',
       promptMessage: 'Il prompt è richiesto',
+      infor: 'Esecuzione informativa',
       knowledgeBasesTip:
-        'Seleziona le basi di conoscenza da associare a questo assistente chat, o scegli variabili contenenti ID di basi di conoscenza qui sotto.',
-      knowledgeBaseVars: 'Variabili base di conoscenza',
+        'Seleziona i dataset da associare a questo assistente chat, o scegli variabili contenenti ID di dataset qui sotto.',
+      knowledgeBaseVars: 'Variabili dataset',
       code: 'Codice',
-      codeDescription:
-        'Permette agli sviluppatori di scrivere logica Python personalizzata.',
-      createAgent: 'Flusso agente',
+      codeDescription: 'Permette agli sviluppatori di scrivere logica Python personalizzata.',
+      dataOperations: 'Operazioni dati',
+      dataOperationsDescription: 'Esegui varie operazioni su un oggetto Data.',
+      listOperations: 'Operazioni lista',
+      listOperationsDescription: 'Esegui operazioni su una lista.',
+      variableAssigner: 'Assegnatore variabili',
+      variableAssignerDescription:
+        'Questo componente esegue operazioni su oggetti Data, inclusi estrazione, filtraggio e modifica di chiavi e valori nel Data.',
+      variableAggregator: 'Aggregatore variabili',
+      variableAggregatorDescription: `
+Questo processo aggrega variabili da più rami in una singola variabile per ottenere una configurazione unificata per i nodi a valle.`,
+      inputVariables: 'Variabili di input',
+      runningHintText: 'è in esecuzione...🕞',
+      openingSwitch: 'Interruttore apertura',
+      openingCopy: 'Saluto di apertura',
+      openingSwitchTip:
+        'I tuoi utenti vedranno questo messaggio di benvenuto all\'inizio.',
+      modeTip: 'La modalità definisce come viene avviato il workflow.',
+      mode: 'Modalità',
+      conversational: 'Conversazionale',
+      task: 'Attività',
+      beginInputTip:
+        'I parametri di input definiti qui possono essere acceduti dai componenti nel workflow a valle.',
+      query: 'Variabili query',
+      switchPromptMessage:
+        'Le parole del prompt cambieranno. Conferma se vuoi scartare le parole del prompt esistenti?',
+      queryRequired: 'La query è richiesta',
+      queryTip: 'Seleziona la variabile che vuoi usare',
       agent: 'Agente',
       addAgent: 'Aggiungi agente',
       agentDescription:
-        'Costruisce componenti agente equipaggiati con ragionamento, uso di strumenti e collaborazione multi-agente.',
+        'Costruisce componenti agente equipaggiati con ragionamento, uso di strumenti e collaborazione multi-agente. ',
+      maxRecords: 'Record massimi',
+      createAgent: 'Flusso agente',
+      stringTransform: 'Elaborazione testo',
+      userFillUp: 'Attendi risposta',
+      userFillUpDescription: `Mette in pausa il workflow e attende il messaggio dell'utente prima di continuare.`,
+      codeExec: 'Codice',
+      tavilySearch: 'Ricerca Tavily',
+      tavilySearchDescription: 'Risultati di ricerca tramite il servizio Tavily.',
+      tavilyExtract: 'Estrazione Tavily',
+      tavilyExtractDescription: 'Tavily Extract',
+      log: 'Log',
+      management: 'Gestione',
+      import: 'Importa',
+      export: 'Esporta',
+      seconds: 'Secondi',
+      subject: 'Oggetto',
+      tag: 'Tag',
+      tagPlaceholder: 'Inserisci tag',
+      descriptionPlaceholder: 'Inserisci descrizione',
+      line: 'Testo a riga singola',
+      paragraph: 'Testo a paragrafo',
+      options: 'Opzioni a discesa',
+      file: 'Caricamento file',
+      integer: 'Numero',
+      boolean: 'Booleano',
+
+      logTimeline: {
+        begin: 'Pronto a iniziare',
+        agent: 'L\'agente sta pensando',
+        userFillUp: 'In attesa di te',
+        retrieval: 'Consultazione della conoscenza',
+        message: 'L\'agente dice',
+        awaitResponse: 'In attesa di te',
+        switch: 'Scelta del percorso migliore',
+        iteration: 'Elaborazione batch',
+        categorize: 'Categorizzazione info',
+        code: 'Esecuzione di uno script rapido',
+        textProcessing: 'Sistemazione del testo',
+        tavilySearch: 'Ricerca sul web',
+        tavilyExtract: 'Lettura della pagina',
+        exeSQL: 'Interrogazione database',
+        google: 'Ricerca sul web',
+        wikipedia: 'Ricerca su Wikipedia',
+        googleScholar: 'Ricerca accademica',
+        gitHub: 'Ricerca su GitHub',
+        email: 'Invio email',
+        httpRequest: 'Chiamata a un\'API',
+        wenCai: 'Interrogazione dati finanziari',
+      },
+      goto: 'Ramo di fallimento',
+      comment: 'Valore predefinito',
+      sqlStatement: 'Istruzione SQL',
+      sqlStatementTip:
+        'Scrivi qui la tua query SQL. Puoi usare variabili, SQL grezzo o mescolare entrambi usando la sintassi delle variabili.',
+      frameworkPrompts: 'Framework',
+      release: 'Pubblica',
+      production: 'Produzione',
+      productionTooltip:
+        'Questa versione è pubblicata in produzione. Accedivi tramite l\'API o la pagina incorporata.',
+      confirmPublish: 'Conferma pubblicazione',
+      publishIngestionPipeline:
+        'Stai per pubblicare questa ingestion pipeline.',
+      publishAgent: 'Stai per pubblicare questo agente',
+      linkedDataset: 'Dataset collegato:',
+      lastPublished: 'Ultima pubblicazione',
+      createFromBlank: 'Crea da vuoto',
+      createFromTemplate: 'Crea da template',
+      importJsonFile: 'Importa file JSON',
+      ceateAgent: 'Workflow',
+      createPipeline: 'Ingestion pipeline',
+      chooseAgentType: 'Scegli il tipo di agente',
+      parser: 'Parser',
+      parserDescription:
+        'Estrae testo grezzo e struttura dai file per l\'elaborazione a valle.',
+      tokenizer: 'Indicizzatore',
+      tokenizerRequired: 'Aggiungi prima il nodo Indicizzatore',
+      tokenizerDescription:
+        'Trasforma il testo nella struttura dati richiesta (es. embedding vettoriali per la ricerca Embedding) a seconda del metodo di ricerca scelto.',
+      tokenChunker: 'Token Chunker',
+      tokenChunkerDescription:
+        'Dividi il testo in chunk per lunghezza di token con delimitatori e sovrapposizione opzionali.',
+      titleChunkerDescription:
+        'Dividi i documenti in sezioni per gerarchia di titoli. Definisci i livelli di intestazione con regole regex, poi scegli la modalità Gerarchia o Gruppo per controllare come sono strutturati i chunk.',
+      titleChunker: 'Title Chunker',
+      extractor: 'Trasformatore',
+      extractorDescription:
+        'Usa un LLM per estrarre insight strutturati dai chunk di documenti—come riassunti, classificazioni, ecc.',
+      outputFormat: 'Formato output',
+      fileFormats: 'Tipo file',
+      fileFormatOptions: {
+        pdf: 'PDF',
+        spreadsheet: 'Foglio di calcolo',
+        image: 'Immagine',
+        email: 'Email',
+        markdown: 'Markdown',
+        'text&code': 'Testo e codice',
+        html: 'HTML',
+        doc: 'DOC',
+        docx: 'DOCX',
+        slides: 'PPTX',
+        audio: 'Audio',
+        video: 'Video',
+      },
+      fields: 'Campo',
+      addParser: 'Aggiungi Parser',
+      rule: 'Regola',
+      addRule: 'Aggiungi regola',
+      group: 'Gruppo',
+      hierarchy: 'Gerarchia',
+      addRegularExpressions: 'Aggiungi espressioni regolari',
+      regularExpressions: 'Espressioni regolari',
+      overlappedPercent: 'Percentuale di sovrapposizione (%)',
+      searchMethod: 'Metodo di ricerca',
+      searchMethodTip: `Definisce come il contenuto può essere cercato — per full-text, embedding o entrambi.
+L'Indicizzatore memorizzerà il contenuto nelle corrispondenti strutture dati per i metodi selezionati.`,
+      parserMethod: 'Parser PDF',
+      tableResultType: 'Tipo risultato tabella',
+      markdownImageResponseType: 'Tipo risposta immagine Markdown',
+      systemPromptPlaceholder:
+        'Inserisci il prompt di sistema per l\'analisi dell\'immagine, se vuoto sarà usato il valore predefinito del sistema',
+      exportJson: 'Esporta JSON',
+      viewResult: 'Visualizza risultato',
+      running: 'In esecuzione',
+      summary: 'Riepilogo',
+      keywords: 'Parole chiave',
+      questions: 'Domande',
+      metadata: 'Metadati',
+      toc: 'PageIndex',
+      fieldName: 'Destinazione risultato',
+      prompts: {
+        system: {
+          keywords: `Ruolo
+Sei un analizzatore di testo.
+
+Compito
+Estrai le parole chiave/frasi più importanti di un dato contenuto di testo.
+
+Requisiti
+- Riassumi il contenuto del testo, e fornisci le 5 parole chiave/frasi più importanti.
+- Le parole chiave DEVONO essere nella stessa lingua del contenuto di testo dato.
+- Le parole chiave sono delimitate da VIRGOLA INGLESE.
+- Output SOLO parole chiave.`,
+          questions: `Ruolo
+Sei un analizzatore di testo.
+
+Compito
+Proponi 3 domande su un dato contenuto di testo.
+
+Requisiti
+- Comprendi e riassumi il contenuto del testo, e proponi le 3 domande più importanti.
+- Le domande NON DEVONO avere significati sovrapposti.
+- Le domande DOVREBBERO coprire il contenuto principale del testo il più possibile.
+- Le domande DEVONO essere nella stessa lingua del contenuto di testo dato.
+- Una domanda per riga.
+- Output SOLO domande.`,
+          summary: `Agisci come un riassuntore preciso. Il tuo compito è creare un riepilogo del contenuto fornito che sia sia conciso che fedele all'originale.
+
+Istruzioni chiave:
+1. Accuratezza: basa rigorosamente il riepilogo sulle informazioni fornite. Non introdurre nuovi fatti, conclusioni o interpretazioni che non siano esplicitamente dichiarati.
+2. Lingua: scrivi il riepilogo nella stessa lingua del testo sorgente.
+3. Obiettività: presenta i punti chiave senza pregiudizi, preservando l'intento e il tono originali del contenuto. Non editorializzare.
+4. Concisione: concentrati sulle idee più importanti, omettendo dettagli minori e riempitivi.`,
+          metadata: `Estrai informazioni strutturate importanti dal contenuto fornito. Output SOLO una stringa JSON valida senza testo aggiuntivo. Se non vengono trovate informazioni strutturate importanti, output un oggetto JSON vuoto: {}.
+
+Le informazioni strutturate importanti possono includere: nomi, date, luoghi, eventi, fatti chiave, dati numerici o altre entità estraibili.`,
+          toc: '',
+        },
+        user: {
+          keywords: `Contenuto testo
+[Inserisci testo qui]`,
+          questions: `Contenuto testo
+[Inserisci testo qui]`,
+          summary: `Testo da riassumere:
+[Inserisci testo qui]`,
+          metadata: `Contenuto: [INSERISCI CONTENUTO QUI]`,
+          toc: '[Inserisci testo qui]',
+        },
+      },
       cancel: 'Annulla',
+      swicthPromptMessage:
+        'La parola del prompt cambierà. Conferma se abbandonare la parola del prompt esistente?',
+      tokenizerSearchMethodOptions: {
+        full_text: 'Full-text',
+        embedding: 'Embedding',
+      },
+      filenameEmbeddingWeight: 'Peso embedding nome file',
+      tokenizerFieldsOptions: {
+        text: 'Testo elaborato',
+        keywords: 'Parole chiave',
+        questions: 'Domande',
+        summary: 'Contesto aumentato',
+      },
+      imageParseMethodOptions: {
+        ocr: 'OCR',
+      },
+      structuredOutput: {
+        configuration: 'Configurazione',
+        structuredOutput: 'Output strutturato',
+      },
+      operations: 'Operazioni',
+      operationsOptions: {
+        selectKeys: 'Seleziona chiavi',
+        literalEval: 'Valutazione letterale',
+        combine: 'Combina',
+        filterValues: 'Filtra valori',
+        appendOrUpdate: 'Aggiungi o aggiorna',
+        removeKeys: 'Rimuovi chiavi',
+        renameKeys: 'Rinomina chiavi',
+      },
+      ListOperationsOptions: {
+        nth: 'N-esimo',
+        head: 'Testa',
+        tail: 'Coda',
+        sort: 'Ordina',
+        filter: 'Filtra',
+        dropDuplicates: 'Rimuovi duplicati',
+      },
+      sortMethod: 'Metodo di ordinamento',
+      strictMode: 'Modalità rigorosa',
+      strictModeTip:
+        'Disattivata usa un comportamento permissivo e restituisce un risultato vuoto per n non valido. Attivata usa un comportamento rigoroso e genera un errore per n fuori intervallo.',
+      SortMethodOptions: {
+        asc: 'Crescente',
+        desc: 'Decrescente',
+      },
+      variableAssignerLogicalOperatorOptions: {
+        overwrite: 'Sovrascritto da',
+        clear: 'Cancella',
+        set: 'Imposta',
+        add: 'Aggiungi',
+        subtract: 'Sottrai',
+        multiply: 'Moltiplica',
+        divide: 'Dividi',
+        append: 'Accoda',
+        extend: 'Estendi',
+        removeFirst: 'Rimuovi primo',
+        removeLast: 'Rimuovi ultimo',
+      },
+      webhook: {
+        name: 'Webhook',
+        methods: 'Metodi',
+        contentTypes: 'Tipi di contenuto',
+        security: 'Sicurezza',
+        schema: 'Schema',
+        response: 'Risposta',
+        executionMode: 'Modalità di esecuzione',
+        executionModeTip:
+          'Risposta accettata: il sistema restituisce un riconoscimento immediatamente dopo che la richiesta è validata, mentre il workflow continua a eseguire in modo asincrono in background. /Risposta finale: il sistema restituisce una risposta solo dopo che l\'esecuzione del workflow è completata.',
+        authMethods: 'Metodi di autenticazione',
+        authType: 'Tipo di autenticazione',
+        limit: 'Limite di frequenza richieste',
+        per: 'Periodo di tempo',
+        maxBodySize: 'Dimensione massima body',
+        ipWhitelist: 'Whitelist IP',
+        tokenHeader: 'Header token',
+        tokenValue: 'Valore token',
+        username: 'Nome utente',
+        password: 'Password',
+        algorithm: 'Algoritmo',
+        secret: 'Secret',
+        issuer: 'Emittente',
+        audience: 'Destinatario',
+        requiredClaims: 'Claim richiesti',
+        header: 'Header',
+        status: 'Stato',
+        headersTemplate: 'Template header',
+        bodyTemplate: 'Template body',
+        basic: 'Basic',
+        bearer: 'Bearer',
+        apiKey: 'Api key',
+        queryParameters: 'Parametri query',
+        headerParameters: 'Parametri header',
+        requestBodyParameters: 'Parametri body richiesta',
+        immediately: 'Risposta accettata',
+        streaming: 'Risposta finale',
+        overview: 'Panoramica',
+        logs: 'Log',
+        agentStatus: 'Stato agente:',
+      },
+      saveToMemory: 'Salva in memoria',
+      retrievalFrom: 'Recupero da',
+      id: 'ID',
+      state: 'Stato',
+      number: 'Numero',
+      latestDate: 'Data più recente',
+      createDate: 'Data creazione',
+      noDataToExport: 'Nessun dato da esportare',
+      success: 'Successo',
+      failed: 'Fallito',
+      logTitle: 'Titolo',
+    },
+    llmTools: {
+      bad_calculator: {
+        name: 'Calcolatrice',
+        description:
+          'Uno strumento per calcolare la somma di due numeri (darà una risposta errata)',
+        params: {
+          a: 'Il primo numero',
+          b: 'Il secondo numero',
+        },
+      },
     },
     modal: {
       okText: 'Conferma',
@@ -1166,7 +2826,7 @@ Quanto sopra è il contenuto che devi riassumere.`,
     search: {
       searchApps: 'Cerca app',
       createSearch: 'Crea ricerca',
-      searchGreeting: 'Come posso aiutarti oggi?',
+      searchGreeting: 'Come posso aiutarti oggi？',
       profile: 'Nascondi profilo',
       locale: 'Locale',
       embedCode: 'Codice embed',
@@ -1208,6 +2868,57 @@ Quanto sopra è il contenuto che devi riassumere.`,
       total: 'Totale {{total}}',
       page: '{{page}} / Pagina',
     },
+    dataflowParser: {
+      result: 'Risultato',
+      parseSummary: 'Riepilogo analisi',
+      parseSummaryTip: 'Parser：DeepDoc',
+      parserMethod: 'Metodo parser',
+      outputFormat: 'Formato output',
+      rerunFromCurrentStep: 'Riesegui dal passaggio corrente',
+      rerunFromCurrentStepTip: 'Modifiche rilevate. Clicca per rieseguire.',
+      confirmRerun: 'Conferma riesecuzione processo',
+      confirmRerunModalContent: `
+      <p class="text-sm text-text-disabled font-medium mb-2">
+        Stai per rieseguire il processo a partire dal passaggio <span class="text-text-secondary">{{step}}</span>.
+      </p>
+      <p class="text-sm mb-3 text-text-disabled">Questo:</p><br />
+      <ul class="list-disc list-inside space-y-1 text-sm text-text-secondary">
+        <li>• Sovrascriverà i risultati esistenti dal passaggio corrente in poi</li>
+        <li>• Creerà una nuova voce di log per il tracciamento</li>
+        <li>• I passaggi precedenti rimarranno invariati</li>
+      </ul>`,
+      changeStepModalTitle: 'Avviso cambio passaggio',
+      changeStepModalContent: `
+      <p>Stai attualmente modificando i risultati di questa fase.</p>
+      <p>Se passi a una fase successiva, le tue modifiche andranno perse. </p>
+      <p>Per mantenerle, clicca Riesegui per rieseguire la fase corrente.</p> `,
+      changeStepModalConfirmText: 'Cambia comunque',
+      changeStepModalCancelText: 'Annulla',
+      unlinkPipelineModalTitle: 'Scollega ingestion pipeline',
+      unlinkPipelineModalConfirmText: 'Scollega',
+      unlinkPipelineModalContent: `
+      <p>Una volta scollegato, questo Dataset non sarà più connesso alla ingestion pipeline corrente.</p>
+      <p>I file che sono già in fase di analisi continueranno fino al completamento</p>
+      <p>I file non ancora analizzati non saranno più elaborati</p> <br/>
+      <p>Sei sicuro di voler procedere?</p> `,
+      unlinkSourceModalTitle: 'Scollega fonte dati',
+      unlinkSourceModalContent: `
+      <p>Sei sicuro di voler scollegare questa fonte dati？</p>`,
+      unlinkSourceModalConfirmText: 'Scollega',
+    },
+    datasetOverview: {
+      downloadTip: 'File in fase di download dalle fonti dati. ',
+      processingTip: 'File in fase di elaborazione dalla ingestion pipeline.',
+      totalFiles: 'File totali',
+      downloading: 'Download in corso',
+      downloadSuccessTip: 'Download totali riusciti',
+      downloadFailedTip: 'Download totali falliti',
+      processingSuccessTip: 'File totali elaborati con successo',
+      processingFailedTip: 'Processi totali falliti',
+      processing: 'Elaborazione',
+      noData: 'Nessun log ancora',
+    },
+
     deleteModal: {
       delAgent: 'Elimina agente',
       delDataset: 'Elimina dataset',
@@ -1219,6 +2930,7 @@ Quanto sopra è il contenuto che devi riassumere.`,
       delMember: 'Elimina membro',
       delMemory: 'Elimina memoria',
     },
+
     empty: {
       noMCP: 'Nessun server MCP disponibile',
       agentTitle: 'Nessuna app agente creata',
@@ -1231,8 +2943,11 @@ Quanto sopra è il contenuto che devi riassumere.`,
       notFoundSearch: 'App ricerca non trovata',
       memoryTitle: 'Nessuna memoria creata',
       notFoundMemory: 'Memoria non trovata',
+      skillsTitle: 'Nessuno spazio skill creato',
+      notFoundSkills: 'Spazio skill non trovato',
       addNow: 'Aggiungi ora',
     },
+
     admin: {
       loginTitle: 'Console admin',
       title: 'RAGFlow',
@@ -1246,11 +2961,65 @@ Quanto sopra è il contenuto che devi riassumere.`,
       import: 'Importa',
       description: 'Descrizione',
       noDescription: 'Nessuna descrizione',
+      none: 'Nessuno',
+
+      resourceType: {
+        dataset: 'Dataset',
+        chat: 'Chat',
+        agent: 'Agente',
+        search: 'Ricerca',
+        file: 'File',
+        team: 'Team',
+        memory: 'Memoria',
+      },
+
+      permissionType: {
+        enable: 'Abilita',
+        read: 'Leggi',
+        write: 'Scrivi',
+        share: 'Condividi',
+      },
+
       serviceStatus: 'Stato servizio',
       userManagement: 'Gestione utenti',
+      sandboxSettings: 'Impostazioni sandbox',
       registrationWhitelist: 'Whitelist registrazione',
       roles: 'Ruoli',
       monitoring: 'Monitoraggio',
+
+      sandboxSettingsPage: {
+        description:
+          'Configura il tuo provider sandbox per l\'esecuzione del codice. La sandbox è usata dal componente Codice negli agenti.',
+        providerSelection: 'Selezione provider',
+        providerSelectionDescription:
+          'Scegli un provider sandbox per l\'esecuzione del codice',
+
+        namedProviderConfiguration: 'Configurazione {{name}}',
+        namedProviderConfigurationDescription:
+          'Configura le impostazioni di connessione per {{name}}.',
+
+        saveConfiguration: 'Salva configurazione',
+        saving: 'Salvataggio...',
+
+        testConnectionResultModal: {
+          title: 'Risultato test connessione',
+          testing: 'Test connessione al provider sandbox...',
+          success: 'Connesso con successo al provider sandbox',
+          failed: 'Impossibile connettersi al provider sandbox',
+
+          exitCode: 'Codice di uscita',
+          executionTime: 'Tempo di esecuzione',
+          stdout: 'Output standard',
+          stderr: 'Output errore / stack trace',
+        },
+
+        testConnection: 'Testa connessione',
+        testing: 'Test in corso...',
+      },
+
+      selectFile: 'Seleziona file',
+      noFileSelected: 'Nessun file selezionato',
+
       back: 'Indietro',
       active: 'Attivo',
       inactive: 'Inattivo',
@@ -1267,29 +3036,105 @@ Quanto sopra è il contenuto che devi riassumere.`,
       serviceType: 'Tipo servizio',
       host: 'Host',
       port: 'Porta',
+
       role: 'Ruolo',
       user: 'Utente',
+      userType: 'Tipo utente',
       superuser: 'Superutente',
+      normalUser: 'Normale',
+
       createTime: 'Data creazione',
       lastLoginTime: 'Ultimo accesso',
       lastUpdateTime: 'Ultimo aggiornamento',
+
+      isAnonymous: 'È anonimo',
+      isSuperuser: 'È superutente',
+
       deleteUser: 'Elimina utente',
       deleteUserConfirmation: 'Sei sicuro di voler eliminare questo utente?',
+
       createNewUser: 'Crea nuovo utente',
       changePassword: 'Cambia password',
       newPassword: 'Nuova password',
       confirmNewPassword: 'Conferma nuova password',
       password: 'Password',
       confirmPassword: 'Conferma password',
+
       invalidEmail: 'Inserisci un indirizzo email valido!',
       passwordRequired: 'Inserisci la tua password!',
       passwordMinLength: 'La password deve essere più di 8 caratteri.',
       confirmPasswordRequired: 'Conferma la tua password!',
       confirmPasswordDoNotMatch: 'Le password inserite non corrispondono!',
+
       read: 'Leggi',
       write: 'Scrivi',
       share: 'Condividi',
       create: 'Crea',
+
+      extraInfo: 'Informazioni extra',
+      serviceDetail: `Dettaglio servizio {{name}}`,
+      taskExecutorDetail: 'Dettaglio task executor',
+
+      whitelistManagement: 'Gestione whitelist',
+      exportAsExcel: 'Esporta Excel',
+      importFromExcel: 'Importa Excel',
+      createEmail: 'Crea email',
+      deleteEmail: 'Elimina email',
+      editEmail: 'Modifica email',
+      deleteWhitelistEmailConfirmation:
+        'Sei sicuro di voler eliminare questa email dalla whitelist? Questa azione non può essere annullata.',
+
+      importWhitelist: 'Importa whitelist (Excel)',
+      importSelectExcelFile: 'File Excel (.xlsx)',
+      importOverwriteExistingEmails: 'Sovrascrivi email esistenti',
+      importInvalidExcelFile: 'Seleziona un file Excel valido',
+      importFileRequired: 'Seleziona un file da importare',
+      importFileTips:
+        'Il file deve contenere una singola colonna di intestazione chiamata <code>email</code>.',
+
+      chunkNum: 'Chunk',
+      docNum: 'Documenti',
+      tokenNum: 'Token usati',
+      language: 'Lingua',
+      createDate: 'Data creazione',
+      updateDate: 'Data aggiornamento',
+      permission: 'Permesso',
+
+      agentTitle: 'Titolo agente',
+      canvasCategory: 'Categoria canvas',
+
+      newRole: 'Nuovo ruolo',
+      addNewRole: 'Aggiungi nuovo ruolo',
+      roleName: 'Nome ruolo',
+      roleNameRequired: 'Il nome del ruolo è richiesto',
+      resources: 'Risorse',
+
+      editRoleDescription: 'Modifica descrizione ruolo',
+      deleteRole: 'Elimina ruolo',
+      deleteRoleConfirmation:
+        'Sei sicuro di voler eliminare questo ruolo? Questa azione non può essere annullata.',
+
+      alive: 'Attivo',
+      timeout: 'Timeout',
+      fail: 'Fallito',
+    },
+    explore: {
+      title: 'Avvia',
+      canvasList: 'Lista Canvas',
+      sessions: 'Sessioni',
+      newSession: 'Nuova sessione',
+      newSessionLabel: 'Avvia una nuova conversazione',
+      deleteSession: 'Elimina sessione',
+      searchCanvas: 'Cerca canvas...',
+      searchSessions: 'Cerca sessioni...',
+      noCanvasSelected: 'Seleziona un canvas',
+      noSessionSelected: 'Seleziona una sessione o creane una nuova',
+      noSessionsFound: 'Nessuna sessione trovata',
+      createFirstSession: 'Crea la tua prima sessione',
+      noCanvasFound: 'Nessun canvas trovato',
+      deleteSelectedConfirm:
+        'Sei sicuro di voler eliminare {{count}} sessioni?',
+      batchDeleteSessions: 'Elimina sessioni',
     },
   },
 };