> ## 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.

# Personalizzazioni di Devin Local

> Estendi l'agente Devin Local in Devin Desktop con regole, competenze, plugin, server MCP e hook, e scopri cosa ha caricato ogni sessione.

Devin Local offre diversi modi per personalizzare il funzionamento dell'agente nei tuoi progetti. Usa questa tabella per scegliere quello più adatto:

| Funzionalità | Cosa fa | Come si attiva | Quando usarla |
| - | - | - | - |
| **[Regole](#rules)** | Indicano all'agente *come comportarsi* (ad es. "usa bun, non npm") | Sempre attive, oppure tramite il campo `trigger` del frontmatter | Convenzioni di codice, guide di stile, vincoli del progetto |
| **[Competenze](#skills)** | Procedure multi-step corredate da file di supporto (script, template) | Invocate dal modello quando pertinenti, oppure da te | Attività complesse in cui l'agente ha bisogno di file di riferimento |
| **[Plugin](#plugins)** | Bundle installabili di competenze, regole, hook, server MCP e sottoagenti | Installati una sola volta, condivisi tra progetti e team | Distribuire un insieme di personalizzazioni |
| **[Server MCP](#mcp-servers)** | Forniscono all'agente strumenti di servizi esterni | Configurati per progetto o per utente | Issue tracker, strumenti di design, API interne |
| **[Hook](#hooks)** | Eseguono comandi della shell o prompt in risposta agli eventi del ciclo di vita dell'agente | Configurati per progetto o per utente | Applicazione delle policy, registrazione, formattatori, notifiche |

Poiché Devin Local condivide il framework dell'agente con [Devin CLI](https://cli.devin.ai), ogni personalizzazione usa lo stesso formato e lo stesso meccanismo di rilevamento di Devin CLI: una personalizzazione scritta per l'uno funziona quindi anche nell'altro.

Per riutilizzare le regole del progetto e i flussi di lavoro di un altro agente sia in Desktop sia in Cloud, parti dal [prompt di migrazione](https://docs.devinenterprise.com/it/onboard-devin/migrate-from-other-agents.md).

## Personalizza

La pagina **Personalizza** nella finestra Agents include le schede **Plugin**, **Competenze**, **MCPs**, **Hook**, **Regole** e **Sottoagenti**. Ogni scheda elenca ciò che l'agente ha caricato, oltre a quanto messo a disposizione dal tuo repository, dalla tua organizzazione e dal tuo account.

Per aprirla, fai clic su **Personalizza** nella barra laterale dell'agente.

## Regole

Le regole sono istruzioni persistenti che determinano il comportamento dell'agente nel tuo progetto. Vengono inserite nel contesto dell'agente all'inizio di ogni sessione, così da mantenere un comportamento coerente in tutto il tuo team.

Le regole vengono usate comunemente per definire standard di programmazione, linee guida architetturali, librerie preferite, convenzioni di testing e vincoli specifici del progetto.

### AGENTS.md

Il modo più semplice per aggiungere regole è creare un file `AGENTS.md` nella directory radice del tuo progetto. Il file usa Markdown semplice, senza frontmatter:

```markdown theme={null}
# Regole del progetto

- Usa TypeScript per tutti i nuovi file
- Segui i pattern esistenti in src/components/
- Esegui sempre `npm run lint` prima di fare commit
- Usa pnpm, non npm o yarn
```

`AGENTS.md`, `AGENTS.local.md` (per le regole personali che tieni fuori dal controllo versione) e `AGENT.md` vengono tutti letti come regole always-on. L'agente li legge nella radice del workspace e in ogni directory compresa tra la radice del workspace e la directory in cui sta lavorando, quindi un file `AGENTS.md` in una sottodirectory fornisce indicazioni specifiche per quella directory.

### File di regole

Per un maggiore controllo, inserisci una regola per file in `.devin/rules/*.md`. Ogni file può dichiarare quando deve essere applicato tramite il campo `trigger` nel frontmatter:

```markdown theme={null}
---
trigger: glob
globs: "**/*.test.ts"
---

Tutti i file di test devono usare blocchi `describe`/`it` e simulare le chiamate API esterne.
```

| Valore di `trigger:` | Quando la regola arriva all'agente |
| - | - |
| `always_on` | In ogni sessione |
| `glob` | Quando l'agente lavora con file corrispondenti a `globs` |
| `model_decision` | Quando l'agente ritiene pertinente la descrizione della regola |
| `manual` | Solo quando la invochi tu |

`.devin/global_rules.md` è un singolo file always-on. Inserisci gli stessi file nella tua directory home (`~/.devin/rules/*.md`, `~/.devin/global_rules.md`) per applicarli a tutti i progetti.

I file legacy `.windsurf/rules/*.md`, `.windsurf/global_rules.md` e `.windsurfrules` vengono importati per impostazione predefinita. I file di regole vengono caricati sia da `.devin/rules/` sia da `.windsurf/rules/`; se esistono entrambi i file `global_rules.md`, viene caricato solo `.devin/global_rules.md`. Consulta [regole e AGENTS.md](https://docs.devinenterprise.com/it/cli/extensibility/rules.md) per l'elenco completo dei file, le impostazioni di importazione e le regole provenienti da altri strumenti.

### Best practice

* Mantieni le regole brevi e specifiche. Le regole fanno parte del contesto di ogni sessione, quindi consumano token a ogni messaggio.
* Per tutto ciò di cui l'agente ha bisogno solo occasionalmente, preferisci una skill e usa una regola per indicargli quali skill usare in scenari specifici.
* Struttura le regole con elenchi puntati, elenchi numerati e intestazioni Markdown: sono più facili da seguire rispetto a un lungo paragrafo.
* Evita regole generiche come "scrivi codice di qualità".

## Competenze

Le attività di ingegneria più complesse spesso richiedono qualcosa in più di prompt ben scritti: script di riferimento, template, checklist e altri file di supporto. Le competenze ti permettono di raggruppare tutti questi elementi in cartelle che l'agente può invocare.

Le competenze adottano la **divulgazione progressiva**: per impostazione predefinita, al modello vengono mostrati solo il `name` e la `description` della competenza. Il contenuto completo di `SKILL.md` e i file di supporto vengono caricati solo quando l'agente decide di invocare la competenza o quando sei tu a invocarla. In questo modo la tua finestra di contesto resta snella anche se hai definito molte competenze.

### Creare una skill

Crea una directory contenente un file `SKILL.md`, nel cui frontmatter YAML sono specificati il nome e la descrizione della skill:

```markdown theme={null}
---
name: deploy-to-production
description: Guida il processo di deployment in produzione con controlli di sicurezza
---

## Checklist pre-deployment
1. Esegui tutti i test
2. Verifica che non ci siano modifiche senza commit
3. Verifica le variabili d'ambiente

## Passaggi del deployment
Segui questi passaggi per eseguire il deployment in sicurezza...
```

* **name**: identificatore univoco della skill (lettere minuscole, numeri e trattini). Serve per invocarla.
* **description**: breve spiegazione mostrata al modello per aiutarlo a decidere quando invocare la skill. Specifica chiaramente cosa fa la skill e quando usarla.

Inserisci i file di supporto nella cartella della skill, accanto a `SKILL.md`. Saranno disponibili per l'agente quando la skill viene invocata:

```
.devin/skills/deploy-to-production/
├── SKILL.md
├── deployment-checklist.md
├── rollback-procedure.md
└── config-template.yaml
```

### Invocare le skill

Quando la tua richiesta corrisponde alla descrizione di una skill, l'agente la invoca automaticamente e ne segue le istruzioni. Puoi anche invocare una skill per nome con `/skill-name` per assicurarti che venga usata.

### Ambiti delle skill

| Ambito | Posizione | Disponibilità |
| - | - | - |
| Workspace | `.devin/skills/<name>/` (vengono letti anche `.agents/skills/` e la cartella legacy `.windsurf/skills/`) | Solo nel workspace attuale. Salvate in un commit nel tuo repo. |
| Globale | `~/.config/devin/skills/<name>/` (viene letto anche `~/.agents/skills/`) | Tutte le aree di lavoro sulla tua macchina. Non salvate in un commit. |
| Plugin | All'interno di un [plugin](#plugins) installato | Ovunque sia installato il plugin. |

Consulta la [documentazione sulle skill di Devin CLI](https://docs.devinenterprise.com/it/cli/extensibility/skills/overview.md) per informazioni su trigger delle skill, autorizzazioni e skill di terze parti, e la pagina [Creazione di skill](https://docs.devinenterprise.com/it/cli/extensibility/skills/creating-skills.md) per indicazioni su come scriverle.

## Plugin

I plugin sono bundle installabili che forniscono all'agente skill, regole, hooks, server MCP e sottoagenti. Puoi installare un plugin da un repository GitHub, da un URL git, da una sottocartella di un repository o da una cartella locale; le sue skill diventano disponibili come comandi `/<plugin>:<skill>`. Per il formato dei plugin, i comandi `devin plugins` e la governance, consulta [plugin](https://docs.devinenterprise.com/it/cli/extensibility/plugins/overview.md).

> [!WARNING]
>
> In questo contesto, **Plugin** indica i plugin dell'*agente* Devin. Non hanno nulla a che vedere con i [Plugin Windsurf](https://docs.devinenterprise.com/it/windsurf/plugins/getting-started.md), che portano Devin su JetBrains, VS Code e altri editor, né con le [estensioni dell'editor](https://docs.devinenterprise.com/it/desktop/recommended-extensions.md) che installi in Devin Desktop: entrambi estendono l'IDE, non l'agente.

## Server MCP

**MCP (Model Context Protocol)** è un protocollo che consente all'agente di usare strumenti di servizi esterni come GitHub, database e sistemi di issue tracking. Per ulteriori informazioni, consulta la [documentazione ufficiale di MCP](https://modelcontextprotocol.io/).

### Installazione dei server MCP

Apri la pagina **Personalizza** dalla finestra Agents e fai clic su **MCPs**. Scegli l'ambito con il selettore **Install MCPs for** in alto, ad esempio **This computer**.

* **This computer** elenca i server che il tuo agente locale carica per le cartelle aperte nella finestra. Puoi attivare o disattivare un server, aprirne il file di configurazione o aggiornare l'elenco.
* **Available** elenca i server dei tuoi registri MCP. Fai clic su **Install** accanto a un server per aggiungerlo.

Gli amministratori Enterprise gestiscono i registri nelle impostazioni del team, in **MCP & ACP**. La scheda **Registro MCP** include un toggle che consente, oltre all'elenco dei server MCP consentiti, anche i server corrispondenti a una voce del registry, e un'impostazione **Registry** (**Configure**) per gli URL dei registri. Se sono configurati più registri, Devin Desktop ne usa l'unione. I registri personalizzati devono rispettare lo [schema ufficiale del registro MCP](https://modelcontextprotocol.io/).

### Configurazione

I server MCP vengono configurati in [file di configurazione](https://docs.devinenterprise.com/it/cli/extensibility/mcp/configuration.md) sulla tua macchina locale. La posizione del file dipende dall'ambito:

| Ambito | Posizione | Condiviso con il team? |
| - | - | - |
| Progetto | `.devin/mcp_config.json` | Sì (incluso nel controllo versione) |
| Override locale | `.devin/mcp_config.local.json` | No (ignorato da Git) |
| Utente | `~/.config/devin/mcp_config.json` | No |

Devin Local supporta i trasporti `stdio`, `Streamable HTTP` e `SSE`, con OAuth per ciascuno di essi.

### Autorizzazioni

Per impostazione predefinita, l'agente chiede l'approvazione prima di chiamare qualsiasi strumento MCP. Consulta [Autorizzazioni MCP](https://docs.devinenterprise.com/it/desktop/devin-local/permissions.md#mcp-permissions) per scoprire come consentire uno strumento o un server e come gli amministratori possono consentire per impostazione predefinita le integrazioni attendibili.

### Riautenticazione

Quando le credenziali OAuth memorizzate di un server scadono, il server mostra lo stato **Needs authentication**. Questo stato viene visualizzato nell'elenco **This computer**, nella scheda **Available** e nella pagina dei dettagli del server.

Fai clic su **Authenticate** per cancellare le credenziali memorizzate e ripetere il flusso di autorizzazione nel browser.

## Hook

Gli hook eseguono logica personalizzata in corrispondenza di determinati eventi del ciclo di vita dell'agente, ad esempio prima di una tool call. Ogni hook è un comando della shell o un prompt per un LLM. Usa gli hook per imporre policy, aggiungere contesto, registrare azioni, modificare le autorizzazioni o integrarti con sistemi esterni.

Gli hook si configurano in `.devin/hooks.v1.json` nel tuo progetto oppure a livello utente. Ad esempio, questo hook esegue uno script prima di ogni comando della shell e può bloccarne l'esecuzione:

```json theme={null}
{
  "PreToolUse": [
    {
      "matcher": "exec",
      "hooks": [
        {
          "type": "command",
          "command": "./scripts/check-command.sh"
        }
      ]
    }
  ]
}
```

Gli hook non vengono né caricati né eseguiti quando un workspace è aperto in [Modalità con restrizioni](https://docs.devinenterprise.com/it/desktop/devin-local/overview.md#restricted-mode).

Consulta [hooks](https://docs.devinenterprise.com/it/cli/extensibility/hooks/overview.md) per gli eventi hook, il formato di configurazione, i codici di uscita e gli esempi.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.