Collegare Claude a strumenti e agent locali con MCP

Intermedio

Vuoi che Claude sia il cervello e che la tua macchina fornisca le mani — leggere i tuoi file, interrogare il tuo database, eseguire il tuo script, persino chiamare un modello locale o un agent locale, il tutto senza che i tuoi dati lascino il laptop. Quella sinergia ha già uno standard: il Model Context Protocol (MCP). In una frase: MCP è uno standard aperto che permette a un client AI di chiamare strumenti e dati esterni attraverso piccoli programmi chiamati server MCP — e quei server possono girare in privato, localmente, sulla tua macchina. Questa pagina mostra cos'è MCP, come si incastra l'architettura locale, come aggiungere un server locale a Claude e come costruirne uno piccolo tuo.

What you'll learn

• Spiegare MCP in una frase — uno standard aperto perché un client AI possa chiamare strumenti e dati esterni via server MCP
• Vedere l'architettura locale: un client MCP (Claude Code / Claude Desktop) che parla con un server MCP locale su stdio
• Capire perché QUESTA è la sinergia Claude-come-cervello + capacità-locali che vuoi
• Aggiungere un server MCP locale a Claude con un solo comando
• Costruire un piccolo server MCP che espone uno strumento
• Conoscere il confine di fiducia — i server MCP agiscono con i TUOI privilegi, quindi installa solo ciò di cui ti fidi

Cos'è MCP (in una frase)

MCP è uno standard aperto per connettere applicazioni AI a sistemi esterni. Un client AI (come Claude) parla un solo protocollo; qualsiasi server MCP che lo parla può innestarsi e offrire al client nuove abilità. L'analogia ufficiale è una porta USB-C per l'AI: invece di un'integrazione su misura per ogni strumento, costruisci verso un solo connettore e funziona ovunque.

Anthropic ha introdotto e reso open source MCP, e fin dal primo giorno è arrivato con il supporto per server MCP locali così che Claude potesse connettersi a sistemi interni e dataset che girano sulla tua macchina.

Ultima verifica: 2026-06-28.

I numeri di adozione, la data di revisione della spec, la governance (la gestione di MCP) e l'elenco esatto dei client che supportano MCP cambiano di frequente. Tratta ogni cifra specifica come deperibile e conferma su modelcontextprotocol.io e nell'annuncio di Anthropic. I fatti duraturi — MCP è uno standard aperto, client ↔ server, i server possono girare localmente, ampiamente adottato tra i client — sono stabili.

Conferma confrontando con la fonte ufficiale.

Un server MCP può esporre tre tipi di cose al client:

• Tool — azioni che il modello può chiamare (leggere un file, eseguire una query, colpire un'API). Ha la stessa forma del tool use nativo del modello: una capacità con nome e input tipizzati.
• Resource — dati che il client può leggere (file, record, documenti).
• Prompt — template di prompt riutilizzabili e parametrizzati che il server offre.

Per questa pagina il titolo sono i tool: un server MCP locale è il modo in cui consegni a Claude una nuova capacità privata.

Perché questa è la sinergia che vuoi

Ciò che la gente intende con "Claude come cervello, il mio computer come corpo" è esattamente la divisione client/server di MCP:

• Claude è l'orchestratore. Legge il tuo obiettivo, decide quale tool chiamare, lo chiama, legge il risultato e decide lo step successivo.
• I server MCP locali sono le capacità. Ciascuno è un piccolo programma che tu esegui sulla tua macchina: un server filesystem, un server database, un wrapper attorno a uno script locale, persino un server che chiama un modello locale o affida il lavoro a un agent locale.

Poiché il server gira localmente e Claude gli parla tramite lo standard input/output della tua macchina, i tuoi dati e le tue azioni restano sul tuo hardware — il modello orchestra, ma le letture di file, l'SQL, l'esecuzione degli script avvengono localmente. È la versione a tutela della privacy del lavoro agentico: cervello nel cloud (o anche locale), mani rigorosamente sulla tua macchina.

E poiché MCP è un solo standard aperto adottato tra molti client, un server che costruisci non è vincolato a una singola app. Lo stesso server locale che colleghi a Claude Code può essere usato da altri client che parlano MCP — costruisci una volta, riusa ovunque.

L'architettura locale

Il quadro utile più piccolo ha due parti e un canale:

• Client MCP (host). L'app AI — per esempio Claude Code o Claude Desktop. Contiene il modello e decide quali tool chiamare.
• Server MCP. Un processo separato che pubblicizza tool/resource/prompt e li esegue quando richiesto.
• Transport. Per i server locali il client avvia il server come sottoprocesso e comunicano su stdio (standard input/output) usando messaggi JSON-RPC. Niente rete, niente porta — solo una pipe locale tra due processi sulla tua macchina. (Esistono anche server remoti, su HTTP; questa pagina riguarda il caso locale, stdio.)

┌─────────────────────────┐         stdio (JSON-RPC)        ┌──────────────────────────┐
│  MCP CLIENT / HOST       │ ──── launches as subprocess ──▶ │  LOCAL MCP SERVER         │
│  Claude Code / Desktop   │ ◀── tools/resources/prompts ─── │  filesystem · db · script │
│  (the model = the brain) │                                 │  · local model / agent    │
└─────────────────────────┘                                  └──────────────────────────┘
                                                              runs on YOUR machine, YOUR data

Il modello non tocca mai direttamente il tuo disco — chiede al server locale, e il server (eseguito con i tuoi permessi) fa il lavoro e restituisce un risultato.

Aggiungere un server MCP locale a Claude

La via più rapida è il comando claude mcp add di Claude Code, che registra un server che il client avvierà su stdio. La forma generale è un nome, poi il comando che avvia il server.

Guided walkthrough1 of 4

1. Parti da un server di riferimento ufficiale (es. il server filesystem) così il comportamento è noto. Anthropic mantiene una raccolta di server MCP di riferimento che puoi eseguire localmente — filesystem, git, memory, fetch e altri.

Un claude mcp add minimale per un server filesystem locale (tutto ciò che segue -- è il comando di avvio):

Aggiungere un server MCP filesystem locale a Claude Code

claude mcp add filesystem -- npx -y @modelcontextprotocol/server-filesystem /path/to/allowed/dir

Se preferisci modificare direttamente la config, un server stdio è dichiarato dal comando che lo avvia. La forma è questa:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/dir"]
    }
  }
}

Ultima verifica: 2026-06-28.

Gli esatti sottocomandi claude mcp, gli scope di configurazione, la posizione del file di config e i nomi precisi dei pacchetti dei server di riferimento evolvono. Conferma la sintassi attuale nella guida MCP di Claude Code e nel repo dei server di riferimento prima di affidarti a un flag o nome di pacchetto specifico.

Conferma confrontando con la fonte ufficiale.

Costruire un piccolo server MCP

Un server è solo un programma che usa un SDK MCP, dichiara un tool e avvia un transport stdio. Ecco l'idea intera in TypeScript — un tool che somma due numeri (sostituisci il corpo con "esegui il mio script", "interroga il mio DB", "chiama il mio modello locale"):

npm install @modelcontextprotocol/sdk zod

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

const server = new McpServer({ name: "my-local-tools", version: "0.1.0" });

// Declare ONE tool. Inputs are typed; the body runs locally with your privileges.
server.registerTool(
  "add",
  {
    description: "Add two numbers",
    inputSchema: { a: z.number(), b: z.number() },
  },
  async ({ a, b }) => ({
    content: [{ type: "text", text: String(a + b) }],
  }),
);

// Talk to the client over stdio — this is what makes it a LOCAL server.
await server.connect(new StdioServerTransport());

Registralo con Claude esattamente come qualsiasi altro server stdio — punta il comando di avvio al tuo file:

Aggiungere il tuo server locale a Claude Code

claude mcp add my-local-tools -- node /abs/path/to/server.js

Ecco il loop completo: Claude (cervello) vede un nuovo tool, lo chiama quando serve, e il tuo codice (mani) gira localmente e restituisce il risultato. Poiché parla lo stesso protocollo aperto, questo server funziona anche in altri client MCP senza modifiche.

Watch out

• I server MCP girano con i tuoi privilegi e possono compiere azioni reali — installa solo server di cui ti fidi, e sta' attento alla prompt-injection via risultati dei tool.

Verifica te stesso

Verifica te stesso

0/4

1. 1In una frase, cos'è MCP?
2. 2Per un server MCP LOCALE, come gli parla di solito il client?
3. 3Perché costruire un solo server MCP ripaga tra più strumenti?
4. 4Qual è il motivo principale per esaminare un server prima di installarlo?

Premi Invio o Spazio per girare la carta. Usa le frecce sinistra e destra per spostarti tra le carte.Termine mostrato.

1 / 8

Key takeaways

• MCP è uno standard aperto perché un client AI possa chiamare strumenti e dati esterni via server MCP — Anthropic lo ha introdotto con il supporto ai server locali fin dall'inizio.
• L'architettura locale è semplice: un client MCP (Claude Code / Desktop) avvia un server MCP locale come sottoprocesso e gli parla su stdio — i tuoi dati restano sulla tua macchina.
• È la sinergia Claude-come-cervello + capacità-locali: Claude orchestra; i server locali (filesystem, DB, uno script, persino un modello o agent locale) forniscono le mani.
• Aggiungi un server con un comando (claude mcp add ... -- <comando di avvio>); costruiscine uno con un SDK MCP registrando un tool e connettendo un transport stdio.
• MCP è ampiamente adottato, quindi un server locale che costruisci funziona su molti client — costruisci una volta, riusa ovunque.
• I server agiscono con i tuoi privilegi: installa solo ciò di cui ti fidi e tratta i risultati dei tool come un possibile vettore di prompt-injection.

Prossimi passi

• Usa MCP dal terminale giorno per giorno → Claude Code: MCP
• Cos'è l'orchestratore → Cos'è Claude Code
• La forma del tool-calling che i tool MCP seguono → Tool use
• Esegui il modello o agent locale che un server può avvolgere → Agent AI locali

Fonti e approfondimenti

• Model Context Protocol — sito ufficiale
• Architettura e concetti di MCP
• Costruire un server MCP (guida ufficiale)
• Introducing the Model Context Protocol — Anthropic
• Server MCP di riferimento (filesystem, git, fetch, …)
• Model Context Protocol — Wikipedia (panoramica e adozione)