> ## Documentation Index
> Fetch the complete documentation index at: https://docs.devinenterprise.com/llms.txt
> Use this file to discover all available pages before exploring further.

# DeepWiki

> Diagrammi dell'architettura, documentazione, link alle fonti e altro ancora per tutti i tuoi repository

<div id="overview">
  ## Panoramica
</div>

Devin ora indicizza automaticamente i tuoi repository e produce wiki con diagrammi dell’architettura, collegamenti alle fonti e riepiloghi della tua codebase.

Usalo per orientarti rapidamente nelle parti della tua codebase che conosci meno: dagli un’occhiata [nella tua barra laterale](https://app.devin.ai/wiki).

[Ask Devin](/it/work-with-devin/ask-devin) utilizzerà le informazioni presenti nel Wiki per comprendere meglio e trovare il contesto pertinente nella tua codebase. Le funzionalità avanzate di ricerca del codice di Ask Devin, combinate con DeepWiki, producono risposte dettagliate e accurate basate sul tuo codice.

<Tip> DeepWiki verrà generato automaticamente quando colleghi i repository durante l’onboarding. </Tip>

<iframe width="840" height="473" src="https://www.youtube.com/embed/lDh9rho5XW8" title="DeepWiki" className="max-w-full" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen />

<div id="for-public-repos">
  ## Per i repository pubblici
</div>

È ora disponibile una versione gratuita di **DeepWiki** e [Ask Devin](/it/work-with-devin/ask-devin) che funziona con i repository GitHub pubblici. Genera automaticamente diagrammi dell’architettura, documentazione e collegamenti al codice sorgente per aiutarti a comprendere rapidamente codebase che non conosci. Puoi anche porre domande complesse sulla codebase per ottenere risposte specifiche basate sul contesto.

<Note>L'esperienza completa di Ask Devin, inclusa la ricerca avanzata nel codice, la pianificazione e la creazione di sessioni, è disponibile nell'[app Devin](https://app.devin.ai). La versione pubblica di DeepWiki e il DeepWiki MCP forniscono funzionalità di documentazione e di domande e risposte di base.</Note>

Visita [deepwiki.com](https://deepwiki.com/) per iniziare a esplorare popolari repository open source come React, TensorFlow, LangChain e molti altri. Puoi anche inserire l'URL del tuo repository GitHub pubblico per l'indicizzazione.

[Prova DeepWiki ora →](https://deepwiki.com/)

<div id="steering-deepwiki">
  ## Gestire DeepWiki
</div>

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/wB0NnCGoy7CGkti6/images/work-with-devin/steering-deepwiki.png?fit=max&auto=format&n=wB0NnCGoy7CGkti6&q=85&s=ea76731afe16b9a910227754dc0d80b8" alt="Steerable Wiki UI" width="2892" height="1714" data-path="images/work-with-devin/steering-deepwiki.png" />
</Frame>

Il file `.devin/wiki.json` ti consente di controllare il comportamento predefinito di generazione della wiki di Devin, il che è particolarmente importante per i repository di grandi dimensioni che potrebbero raggiungere i limiti predefiniti.

Se durante la generazione della wiki viene trovato un file `.devin/wiki.json` nella directory radice del tuo repository, utilizzeremo i `repo_notes` e `pages` forniti per orientare la generazione della wiki. Se `pages` è presente, salteremo la pianificazione predefinita basata sui cluster e creeremo esattamente le pagine che specifichi. Questo garantisce che le parti importanti della tua base di codice vengano documentate anche quando il sistema automatico altrimenti le ignorerebbe.

<div id="configuration-format">
  ## Formato di configurazione
</div>

Crea un file `.devin/wiki.json` nella directory principale del repository con la seguente struttura:

```json theme={null}
{
  "repo_notes": [
    {
      "content": "Questo repository contiene i componenti UI principali nella cartella cui/, che devono avere priorità nella documentazione",
      "author": "Team Lead"
    }
  ],
  "pages": [
    {
      "title": "Panoramica componenti CUI",
      "purpose": "Documentare la struttura della cartella cui/ e i componenti UI principali",
      "parent": null
    },
    {
      "title": "Sistema di autenticazione",
      "purpose": "Documentare il flusso di autenticazione e i componenti correlati",
      "parent": null
    },
    {
      "title": "Componenti di login",
      "purpose": "Documentazione dettagliata dei componenti UI relativi al login",
      "parent": "Authentication System"
    }
  ]
}
```

<div id="configuration-options">
  ## Opzioni di configurazione
</div>

<div id="repo_notes-array">
  ### repo\_notes (Array)
</div>

Fornisce contesto e indicazioni per aiutare il sistema di documentazione a comprendere meglio il repository.

* **content** (string, required): il contenuto della nota (fino a 10.000 caratteri)
* **author** (string, optional): chi ha scritto la nota

<div id="pages-array-optional">
  ### pages (Array, facoltativo)
</div>

Specifica esattamente quali pagine devono essere create nella tua wiki.

Questo campo è facoltativo. Se includi solo repo\_notes, il sistema genererà comunque una wiki, usando le tue note per guidarne struttura e contenuti, senza richiederti di definire ogni singola pagina.

Quando specifichi pages, queste vengono trattate come istruzioni esplicite. Verranno generate solo le pagine che definisci nel JSON, né più né meno.

* **title** (string, obbligatorio): Il titolo della pagina (deve essere univoco e non vuoto)
* **purpose** (string, obbligatorio): Cosa deve documentare questa pagina
* **parent** (string, facoltativo): Titolo della pagina padre per l'organizzazione gerarchica
* **page\_notes** (array, facoltativo): Note aggiuntive specifiche per questa pagina

<div id="validation-limits">
  ### Limiti di convalida
</div>

* Massimo 30 pagine (80 per i clienti enterprise)
* Massimo 100 note complessive (repo\_notes + tutte le page\_notes combinate)
* Massimo 10.000 caratteri per nota
* I titoli delle pagine devono essere univoci e non vuoti

<div id="practical-examples">
  ## Esempi pratici
</div>

<div id="example-1-repo-notes-to-guide-wiki-generation">
  ### Esempio 1: Repo Notes per guidare la generazione della wiki
</div>

Se preferisci non definire pagine specifiche, puoi fornire solo le repo\_notes per guidare la generazione della wiki. Questo consente a Devin di creare automaticamente la struttura della documentazione, tenendo comunque conto delle tue priorità e delle aree su cui vuoi concentrarti. È utile quando vuoi una copertura e un'enfasi migliori senza dover definire esplicitamente ogni pagina.

```json theme={null}
{
  "repo_notes": [
    {
      "content": "Il repository contiene tre aree principali: la cartella frontend/ con i componenti React, la cartella backend/ con i servizi API e la cartella infra/ con gli script di deployment. La documentazione deve evidenziare come queste parti interagiscono e mettere in risalto il livello API backend come priorità principale."
    }
  ]
}
```

<div id="example-2-ensuring-specific-folders-are-documented">
  ### Esempio 2: Assicurarsi che cartelle specifiche siano documentate
</div>

Se il tuo repository di grandi dimensioni contiene cartelle importanti che non vengono incluse nella wiki, indicale esplicitamente:

```json theme={null}
{
  "repo_notes": [
    {
      "content": "La cartella cui/ contiene componenti UI critici che devono essere documentati. La cartella backend/ contiene la logica API principale. La cartella utils/ contiene utility condivise utilizzate in tutta la codebase."
    }
  ]
}
```

<div id="example-3-addressing-missing-components">
  ### Esempio 3: Gestione dei componenti mancanti
</div>

Se noti che alcune parti della tua codebase non vengono documentate:

```json theme={null}
{
  "repo_notes": [
    {
      "content": "La directory testing/ contiene utility e pattern di test importanti che gli sviluppatori devono conoscere. La directory scripts/ contiene script di deployment e manutenzione essenziali per le operazioni."
    }
  ]
}
```

<div id="example-4-hierarchical-documentation-structure">
  ### Esempio 4: Struttura gerarchica della documentazione
</div>

Per i repository complessi, organizza le pagine in modo gerarchico:

```json theme={null}
{
  "repo_notes": [
    {
      "content": "Si tratta di un'applicazione full-stack con componenti frontend, backend e condivisi distinti che devono essere documentati separatamente ma con relazioni chiare tra loro."
    }
  ],
  "pages": [
    {
      "title": "Panoramica dell'Architettura",
      "purpose": "Panoramica ad alto livello dell'architettura dell'applicazione e delle interazioni tra componenti"
    },
    {
      "title": "Frontend",
      "purpose": "Struttura e componenti dell'applicazione frontend",
      "parent": "Panoramica dell'Architettura"
    },
    {
      "title": "Componenti React",
      "purpose": "Documentazione dettagliata dei componenti React, delle loro props e del loro utilizzo",
      "parent": "Frontend"
    },
    {
      "title": "Gestione dello Stato",
      "purpose": "Gestione dello stato dell'applicazione, inclusi store e flusso dei dati",
      "parent": "Frontend"
    },
    {
      "title": "Backend",
      "purpose": "Servizi backend, API e livello dati",
      "parent": "Panoramica dell'Architettura"
    },
    {
      "title": "Endpoint API",
      "purpose": "Documentazione delle API REST con endpoint e formati di richiesta/risposta",
      "parent": "Backend"
    }
  ]
}
```

<div id="best-practices">
  ## Best practice consigliate
</div>

<div id="1-use-repo-notes-strategically">
  ### 1. Usa le Repo Notes in modo strategico
</div>

* Fornisci contesto su quali parti della tua codebase sono più importanti
* Indica cartelle o componenti specifici a cui dare priorità
* Spiega le relazioni tra le diverse parti del tuo sistema

<div id="2-organize-pages-logically">
  ### 2. Organizza le pagine in modo logico
</div>

* Inizia con pagine di panoramica ad alto livello
* Usa relazioni padre-figlio per creare gerarchie chiare
* Raggruppa le funzionalità correlate

<div id="3-be-specific-in-page-purposes">
  ### 3. Sii specifico negli obiettivi di ogni pagina
</div>

* Indica chiaramente cosa dovrebbe documentare ciascuna pagina
* Specifica le directory, i file o i concetti su cui concentrarsi
* Fornisci dettagli sufficienti affinché il sistema comprenda le tue intenzioni

<div id="4-address-known-gaps">
  ### 4. Colma le lacune note
</div>

* Se sai che alcune parti della tua codebase vengono escluse, includile esplicitamente
* Usa titoli descrittivi che rendano chiaro cosa deve essere trattato

<div id="troubleshooting-common-issues">
  ## Risoluzione dei problemi più comuni
</div>

<div id="only-certain-folders-are-being-documented">
  ### "Solo alcune cartelle vengono documentate"
</div>

Questo è il classico problema dei repository di grandi dimensioni.

**Soluzione:** Usa `.devin/wiki.json` per specificare in modo esplicito quali parti della tua codebase devono essere documentate.

<Tip>Inizia aggiornando solo repo\_notes e rigenera la wiki con quel contesto aggiuntivo per verificare se la wiki aggiornata includerà le cartelle mancanti. Aggiungi l’array pages solo se necessario.</Tip>

<div id="important-components-are-missing-from-the-wiki">
  ### "Mancano componenti importanti nella wiki"
</div>

Aggiungi pagine specifiche per questi componenti e usa repo\_notes per evidenziarne l'importanza.

<Tip>Ricorda: DeepWiki genererà solo le pagine incluse in questo array, quindi assicurati che siano presenti tutte le pagine, non solo quella mancante.</Tip>

```json theme={null}
{
  "repo_notes": [
    {
      "content": "La directory [missing-component] è essenziale per l'applicazione e deve essere documentata in modo completo."
    }
  ],
  "pages": [
    {
      "title": "Nome del componente critico",
      "purpose": "Documentare la directory [missing-component] e le sue funzionalità"
    }
  ]
}
```

<div id="getting-started">
  ## Per iniziare
</div>

1. Crea `.devin/wiki.json` nella directory principale del tuo repository
2. Aggiungi `repo_notes` che spieghino la struttura della tua codebase e le priorità
3. Se necessario, specifica **tutte** le pagine che vuoi vengano create, con titoli e obiettivi chiari
4. Esegui il commit del file e rigenera la tua wiki

Il sistema ora creerà la documentazione in base alle tue istruzioni esplicite, anziché tramite analisi completamente automatica, garantendo una copertura più completa e accurata dei repository di grandi dimensioni.