Noi e terze parti selezionate usiamo cookie o tecnologie simili per finalità tecniche e, con il tuo consenso, per analizzare l’uso del sito.

Puoi liberamente prestare, negare o revocare il tuo consenso in qualsiasi momento.

API e dati

Tutto nell’elenco è pubblico e leggibile dalle macchine: un’API nel formato del registro ufficiale MCP, un indice di ricerca JSON, ogni scheda in JSON e Markdown, più llms.txt, un feed e le sitemap. Niente chiave, niente registrazione.

In breve

URLCosa ottieniIn cache per
/v0.1/serversLe schede nel formato del registro ufficiale MCP, a pagine. Dettagli5 minuti
/api/index.jsonTutte le schede in un unico array compatto. Dettagli5 minuti
/i/{slug}.jsonUna scheda, con le sue azioni di configurazione. Dettagli10 minuti
/i/{slug}.mdUna scheda in Markdown. Dettagli15 minuti
/llms.txtL’elenco come lista per i modelli linguistici.1 ora
/feed.xmlFeed Atom delle 50 schede più recenti.15 minuti
/changes.xmlFeed Atom delle 50 modifiche più recenti in tutto l’elenco. Dettagli15 minuti
/i/{slug}/history.xmlFeed Atom della Cronologia di una scheda. Dettagli15 minuti
/sitemap.xmlIndice delle sitemap: pagine, categorie e schede, in tutte le lingue.15 minuti
/mcpIl server MCP di mcp.tc. DocumentazioneNessuna cache
POST /submitProponi un server per l’elenco da uno script. DettagliNessuna cache
/openapi.jsonDescrizione OpenAPI 3.1 dell’API del registro, dell’indice di ricerca, del JSON e Markdown delle schede, dei feed delle modifiche e di POST /submit con il suo stato.1 ora
/.well-known/…File di scoperta per agenti: catalogo delle API, server card MCP, catalogo AI e una skill per agenti. Dettagli1 ora
/AGENTS.mdUna guida per gli agenti AI: come collegarsi, limiti e regole d’uso. Dettagli1 ora
/{page}.mdQualsiasi pagina in Markdown, nella sua lingua. DettagliFino a 5 minuti

Tutto è pubblico, e tutto è in sola lettura tranne POST /submit. Niente chiave, niente account, niente costi. I formati per le macchine sono indipendenti dalla lingua: servono il testo inglese delle schede e non hanno prefisso di lingua. Fa eccezione il Markdown delle pagine, che segue la lingua della pagina.

API compatibile con il registro

https://mcp.tc/v0.1/ è una copia in sola lettura dell’API di lettura del registro ufficiale MCP (versione 0.1, schema server.json 2025-12-11), riempita con le schede approvate di mcp.tc. Un client che accetta l’URL di un registro personalizzato può sfogliare l’elenco e installare da lì.

GET /v0.1/servers

Server ordinati per nome, 30 per pagina se non imposti limit (da 1 a 100). Rimanda metadata.nextCursor come cursor per la pagina successiva. search tiene i server il cui nome, titolo, slug o fornitore contiene ogni parola (l’API ufficiale cerca solo nel nome). updated_since accetta un timestamp RFC 3339 (estremo incluso) e restituisce anche le schede rimosse da allora. version (latest o una versione) e include_deleted funzionano come nell’API ufficiale.

GET /v0.1/servers/{name}/versions

Le versioni di un server. Ogni scheda ne ha esattamente una. Codifica il nome nell’URL, come in /v0.1/servers/tc.mcp%2Fdeepwiki/versions.

GET /v0.1/servers/{name}/versions/latest

Un server. Al posto di latest funziona anche un numero di versione esatto.

GET /v0.1/ping, /v0.1/health, /v0.1/version

Stato del servizio e informazioni sulla build, come nell’API ufficiale.

Una pagina di risultati ha questa forma:

GET /v0.1/servers
{
  "servers": [
    {
      "server": { "name": "…", "version": "…", … },
      "_meta": {
        "tc.mcp/listing": {
          "link": "https://mcp.tc/i/…",
          "slug": "…",
          "category": "…",
          "verified": true,
          "auth": "none",
          "status": "active",
          "publishedAt": "…",
          "updatedAt": "…"
        }
      }
    }
  ],
  "metadata": { "count": 30, "nextCursor": "…" }
}

Ed ecco cosa contiene server per due schede, così come l’API le serve adesso:

Server remoto

server (tc.mcp/deepwiki)
{
  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
  "name": "tc.mcp/deepwiki",
  "description": "Ask questions about any public GitHub repository and read its AI-generated DeepWiki documentation.",
  "title": "DeepWiki",
  "version": "4.0.2",
  "websiteUrl": "https://docs.devin.ai/work-with-devin/deepwiki-mcp",
  "icons": [
    {
      "src": "https://mcp.tc/media/icons/deepwiki-80b7a72d.webp",
      "mimeType": "image/webp",
      "sizes": [
        "128x128"
      ]
    }
  ],
  "remotes": [
    {
      "type": "streamable-http",
      "url": "https://mcp.deepwiki.com/mcp"
    }
  ]
}

Server locale

server (tc.mcp/memory)
{
  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
  "name": "tc.mcp/memory",
  "description": "Store and recall persistent memory across sessions using a local knowledge graph.",
  "title": "Memory",
  "version": "2.1.1",
  "websiteUrl": "https://github.com/modelcontextprotocol/servers/tree/main/src/memory",
  "repository": {
    "url": "https://github.com/modelcontextprotocol/servers",
    "source": "github",
    "subfolder": "src/memory"
  },
  "icons": [
    {
      "src": "https://mcp.tc/media/icons/memory-0e174415.webp",
      "mimeType": "image/webp",
      "sizes": [
        "128x128"
      ]
    }
  ],
  "packages": [
    {
      "registryType": "npm",
      "identifier": "@modelcontextprotocol/server-memory",
      "runtimeHint": "npx",
      "transport": {
        "type": "stdio"
      }
    }
  ]
}
  • name è il nome del server nel registro ufficiale quando ne ha uno, altrimenti tc.mcp/{slug}.
  • remotes contiene sempre l’URL del server stesso, mai il link di mcp.tc. Gli header per le chiavi compaiono solo per i server che richiedono una chiave API.
  • packages viene ricostruito dal comando di installazione della scheda: npm (npx), PyPI (uvx, pipx run), OCI (docker run) e NuGet (dnx). Un comando che il formato non può esprimere non riceve alcun pacchetto, perché uno che avvia il programma sbagliato sarebbe peggio di niente.
  • _meta["tc.mcp/listing"] contiene il link di mcp.tc, lo slug, la categoria, la spunta, l’accesso, lo stato e le date. updatedAt cambia solo quando cambia la voce che serviamo, mai per un controllo di stato.
  • mcp.tc non è il registro ufficiale, quindi le voci non hanno mai i suoi metadati io.modelcontextprotocol.registry/official.
  • Una scheda rimossa, nascosta o rinominata torna come voce con "status": "deleted" per 180 giorni, ma solo se la chiedi con updated_since o include_deleted.

Gli errori sono problem JSON (application/problem+json), come nell’API ufficiale: 404 per un server sconosciuto, 422 per un limit, cursor o include_deleted non validi, 400 per un updated_since non valido. Qualsiasi metodo diverso da GET, HEAD e OPTIONS riceve 405: il registro è in sola lettura, e i nuovi server arrivano da Proponi.

L’API è descritta in OpenAPI 3.1 su https://mcp.tc/openapi.json, e ogni risposta vi rimanda con un’intestazione Link.

curl -s 'https://mcp.tc/v0.1/servers?search=notion&limit=5'
curl -s 'https://mcp.tc/v0.1/servers/tc.mcp%2Fdeepwiki/versions/latest'

Usa mcp.tc come registro

Questi client accettano l’URL di un registro personalizzato, secondo il codice sorgente di VS Code e la documentazione di GitHub (verificato l’8 ottobre 2026). In VS Code e nelle policy di Copilot inserisci l’URL di base senza /v0.1: il percorso lo aggiungono loro.

VS Code

Aggiungi questa riga al settings.json utente del tuo profilo predefinito:

settings.json
"chat.mcp.gallery.serviceUrl": "https://mcp.tc"

La galleria dei server MCP (digita @mcp nella vista Estensioni) mostra allora i server di mcp.tc, e installarne uno usa l’URL o il pacchetto del server stesso. Non serve nessun’altra impostazione. L’impostazione non compare nell’editor delle impostazioni, e gli altri profili la ignorano, a meno che il settings.json del profilo predefinito contenga anche "workbench.settings.applyToAllProfiles": ["chat.mcp.gallery.serviceUrl"]. Le organizzazioni possono impostarla per tutti con la policy McpGalleryServiceUrl (VS Code 1.101 o successivo), e "chat.mcp.access": "registry" limita VS Code ai server di quel registro.

GitHub Copilot

Gli amministratori di organizzazioni ed enterprise possono inserire https://mcp.tc come MCP Registry URL nelle policy di Copilot. GitHub indica come supportati VS Code, Visual Studio, gli IDE JetBrains, Eclipse, Xcode e Copilot CLI. Con Registry only, i server vengono abbinati per nome, e secondo GitHub gli utenti possono aggirarlo modificando la propria configurazione. GitHub definisce questa strada un’anteprima pubblica e non il modo consigliato per limitare i server: consiglia una lista di server ammessi nel managed-settings.json dell’enterprise.

Copilot negli IDE JetBrains, in Xcode ed Eclipse

Gli utenti possono inserire un registro anche nelle impostazioni di Copilot (MCP Registry URL), in anteprima pubblica sulle build pre-release del plugin. GitHub non dice se quel campo vuole l’URL di base o il percorso /v0.1, e non abbiamo provato mcp.tc lì.

Alcune schede non hanno né un pacchetto né un remote, perché il loro comando di installazione non si può scrivere nel formato del registro. VS Code le nasconde; le loro pagine su mcp.tc hanno comunque la configurazione.

Indice di ricerca

/api/index.json contiene tutte le schede approvate in un unico array JSON, i dati dietro la ricerca del sito. Le chiavi brevi lo tengono leggero:

ChiaveValore
sSlug: la scheda è a /i/{s}.
nNome.
vFornitore, o una stringa vuota.
tDescrizione breve, fino a 160 caratteri (in inglese).
cSlug della categoria, come in /c/{slug}.
kremote o local.
aAccesso: none, oauth, api_key, optional o unknown.
gTag, un array di stringhe.
iIcona, un percorso come /media/icons/{slug}.webp (WebP o PNG). Assente quando la scheda non ne ha.
f1 quando la scheda ha la spunta. Altrimenti assente.
Una voce
{
  "s": "deepwiki",
  "n": "DeepWiki",
  "v": "Cognition",
  "t": "Ask questions about any public GitHub repository and read its AI-generated DeepWiki documentation.",
  "c": "docs-knowledge",
  "k": "remote",
  "a": "none",
  "g": [
    "github",
    "documentation",
    "code-search",
    "repositories",
    "wiki",
    "remote"
  ],
  "i": "/media/icons/deepwiki-80b7a72d.webp",
  "f": 1
}

Una scheda in JSON

Aggiungi .json al link di qualsiasi scheda per avere quella scheda in JSON:

curl -s https://mcp.tc/i/deepwiki.json

Contiene tutto ciò che mostra la pagina: l’endpoint del server o il suo install_command, l’etichetta access, i tool, la spunta, lo stato e le azioni in un clic add, che usano sempre l’URL o il pacchetto del server stesso. L’oggetto history rimanda alla Cronologia della scheda: il suo url e il feed Atom, cosa controlliamo (tracking: tools, version o listing), quando abbiamo letto i suoi tool l’ultima volta (tools_checked) e quando è cambiata l’ultima volta (last_changed), entrambi in ISO 8601 o null. Uno slug non in elenco riceve 404 con "error": "not_found", e una scheda rimossa 410 con "gone". I vecchi slug e gli alias restituiscono la scheda attuale, quindi leggi slug dalla risposta.

Qualsiasi sito può leggerla: la risposta include Access-Control-Allow-Origin: * e non richiede chiavi. I campi senza valore sono null, mai omessi. Il testo è quello originale inglese della scheda, a meno che tu non aggiunga ?lang= (lingue). Tutti i campi:

CampoTipoCos’è
slugstringaLo slug attuale della scheda. I vecchi slug e gli alias restituiscono la scheda attuale, quindi leggilo da qui.
namestringaNome del server.
vendorstringa o nullChi realizza il server.
taglinestringa o nullUna riga, fino a 200 caratteri.
descriptionstringa o nullTesto semplice, paragrafi separati da una riga vuota, fino a 2.000 caratteri. L’ha scritto un modello di AI dai metadati pubblici del server.
linkstringaLa pagina della scheda, https://mcp.tc/i/{slug}, oppure, con ?lang=, la pagina in quella lingua quando è tradotta.
lang
text_lang
stringalang: la lingua delle etichette (en, a meno che tu non ne chieda un’altra con ?lang=). text_lang: la lingua di tagline, description e dei riassunti degli strumenti: lang quando la scheda ha una traduzione aggiornata, altrimenti en. Un tool la cui descrizione è cambiata dopo l’ultima traduzione mantiene il riassunto in inglese finché non viene tradotto di nuovo.
category
category_name
stringa o nullSlug della categoria (come in /c/{slug}) e il suo nome.
kindstringaremote (ti colleghi via HTTPS) o local (gira sul tuo computer).
transportstringastreamable-http, sse o stdio.
authstringanone, oauth, api_key, optional o unknown.
accessoggettoCome lo etichetta mcp.tc: group (ok, auth o local, il filtro Accesso dell’elenco), label (testo del badge, come «No sign-in»), text (forma estesa) e note (una frase).
endpointstringa o nullL’URL del server stesso (server remoti). È quello a cui si collega un client.
install_commandstringa o nullIl comando che avvia un server locale, come npx -y @playwright/mcp.
packageoggetto o nullregistry (npm, pypi, oci, nuget…) e identifier.
relaybooleanoFalse per ogni scheda: il link di mcp.tc è una pagina, e i client si collegano all’URL del server stesso. Il campo resta perché i programmi che già lo leggono continuino a funzionare.
verified
verified_by
booleano, stringa o nullLa spunta, e cosa significa per questa scheda.
iconstringa o nullURL dell’icona 128 × 128 della scheda su mcp.tc.
tools_count
tools
numero, arrayI tool letti dal server (fino a 150): name, summary e read_only / destructive (true, false, o null quando il server non lo dice).
addarrayLe azioni in un clic: client (claude-code, cursor, vscode, claude-ai), label, kind e value: un comando da copiare per copy, un link di installazione per link. Usano sempre l’URL o il pacchetto del server stesso.
homepage
repository
docs
stringa o nullLink della scheda.
healthstringaIl nostro ultimo controllo: ok, auth (ha risposto e ha chiesto un accesso), down o unknown (i server locali non vengono controllati).
last_checked
listed
updated
stringa o nullOrari ISO 8601 in UTC: l’ultimo controllo, l’inserimento in elenco, l’ultima modifica del contenuto.
historyoggettoLa Cronologia della scheda: url (la Cronologia sulla sua pagina) e feed (Atom), cosa controlliamo in tracking (tools, version o listing) e due orari ISO 8601 in UTC, oppure null: tools_checked (quando abbiamo letto i suoi tool l’ultima volta) e last_changed (la sua modifica più recente).
embedsoggettoGli URL di badge, widget, iframe e markdown di questa scheda. widget e iframe mantengono il tuo ?lang=. snippets contiene il codice della sezione Embed della pagina della scheda, pronto da incollare: markdown e html per il badge, script per la card per il sito, placeholder (un div in cui compare la card, con dentro un link per chi non ha JavaScript) e iframe. Testo alternativo e link seguono ?lang=.
formatstringaUn link a questo elenco di campi.

Badge ed embed

Come si comporta la card per il sito sulla tua pagina:

  • Ogni file contiene tutto: i dati della scheda, gli stili e l’icona. Non fa altre richieste e non imposta cookie né local storage, quindi non c’è nulla con cui tracciare chi visita.
  • Si disegna dentro una shadow root chiusa: i tuoi stili non la raggiungono e i suoi non raggiungono la tua pagina.
  • Scrive il testo solo come testo (mai come HTML) e rimanda solo a mcp.tc e alle pagine di installazione dei client, in HTTPS.
  • Con una Content Security Policy, consenti script-src https://mcp.tc. L’icona è un’immagine data:; se la tua policy le blocca, la card mostra invece l’iniziale del nome.
  • Per uno slug non in elenco non compare nulla e la console del browser mostra un avviso.

Per quanto tempo vengono conservate le copie

  • La card, l’iframe e il JSON contengono pulsanti di installazione, quindi si aggiornano in fretta. I browser li conservano per 10 minuti, e una modifica alla scheda raggiunge le copie della nostra CDN (Cloudflare) entro 15 minuti.
  • Il badge mostra solo un nome. Cloudflare lo conserva fino a un giorno e i browser per un’ora; mentre Cloudflare aggiorna una copia, può servire quella vecchia fino a una settimana.

Pagine e schede in Markdown

Per agenti e modelli linguistici, ogni scheda è disponibile anche in Markdown: aggiungi .md al link, oppure chiedi text/markdown all’indirizzo della scheda.

curl -s https://mcp.tc/i/deepwiki.md
curl -s -H 'Accept: text/markdown' https://mcp.tc/i/deepwiki

Inizia con un riepilogo (il link, come collegarsi, tipo, accesso, categoria, fornitore, spunta), poi contiene la descrizione, cosa può fare il server, i suoi tool, i prompt di esempio, i passaggi di installazione per ogni client e le sue cinque modifiche più recenti. Un vecchio nome risponde 301 con quello attuale.

Le pagine del sito funzionano allo stesso modo: la home, l’elenco e le sue categorie, questa documentazione, il blog, le modifiche recenti, la pagina della spunta e le pagine legali. Aggiungi .md all’indirizzo (/docs/connect.md, /it/c/databases.md; la home è /index.md) oppure chiedi text/markdown alla pagina stessa. Ricevi il testo della pagina nella sua lingua, senza menu, sotto una breve intestazione di metadati. Una richiesta il cui header Accept preferisce text/markdown lo riceve con Vary: Accept, e x-markdown-tokens indica un numero approssimativo di token (i caratteri divisi per quattro). Le copie .md sono noindex, così i motori di ricerca continuano a indicizzare la pagina HTML.

llms.txt, feed e sitemap

  • /llms.txt segue llmstxt.org: come funziona il collegamento, questa documentazione, le categorie con i loro conteggi, le versioni linguistiche del sito e ogni scheda con un riassunto di una riga e dati essenziali (remoto o locale, accesso, verificato), ognuna collegata al suo Markdown.
  • /feed.xml è un feed Atom delle 50 schede approvate più di recente, con descrizione breve e descrizione.
  • /changes.xml è un feed Atom delle 50 modifiche più recenti in tutto l’elenco (tool aggiunti, rimossi o modificati, nuove versioni, modifiche di chi gestisce i server), ognuna con un link alla Cronologia della scheda. La pagina Modifiche recenti mostra lo stesso elenco.
  • /i/{slug}/history.xml è la Cronologia di una scheda come feed Atom, per esempio /i/deepwiki/history.xml. Cronologia e avvisi spiega cosa conta come modifica.
  • /sitemap.xml indicizza tre sitemap: pagine, categorie e schede, ognuna con la data dell’ultima modifica del contenuto. Ogni pagina compare in ogni lingua in cui esiste, con le sue alternative (hreflang); le pagine tradotte di una scheda compaiono quando il suo testo è stato tradotto.
  • /robots.txt lascia entrare ogni crawler, compresi quelli AI (Content-Signal: search=yes, ai-input=yes, ai-train=yes). Li tiene fuori da /api/, tranne l’indice di ricerca, e dalle pagine private delle proposte.

Proporre un server da uno script

Il modulo Proponi accetta anche JSON. Invia una richiesta POST a https://mcp.tc/submit con Content-Type: application/json, l’URL del server e, se vuoi, una nota per chi la esamina:

curl -s https://mcp.tc/submit \
  -H 'Content-Type: application/json' \
  -d '{"url": "https://mcp.example.com/mcp", "note": "The official server of Example."}'
  • url (obbligatorio): un endpoint MCP remoto, un repository o una pagina npm o PyPI, fino a 2.048 caratteri.
  • note (facoltativo): fino a 500 caratteri. L’URL e la nota vengono controllati in automatico, anche da un modello di AI, quindi non inserire dati personali.
  • notify_email (facoltativo): l’indirizzo di chi suggerisce il server, che riceve una sola email in inglese quando è in elenco (la risposta 202 ha allora "notify": true). Aggiungilo solo con il consenso di quella persona. Un indirizzo può aspettare cinque server alla volta.

Gli altri campi vengono ignorati. Una proposta inviata così passa per gli stessi controlli e gli stessi limiti di una inviata con il modulo, e non servono chiavi né account. Solo l’indirizzo senza prefisso di lingua accetta JSON. La risposta non ha intestazioni CORS, quindi una pagina di un altro sito non può inviarla, e una richiesta che il browser segna come cross-site riceve 403.

Una proposta accettata riceve 202, con l’URL dello stato anche nell’intestazione Location:

HTTP 202
{
  "ok": true,
  "state": "queued",
  "token": "{token}",
  "status_url": "https://mcp.tc/s/{token}.json",
  "page": "https://mcp.tc/s/{token}"
}
Statostate o errorCosa significa
202queuedIn coda: seguila su status_url. Se lo stesso URL è già in attesa, ricevi il token di quella proposta e "existing_submission": true.
200duplicateGià nell’elenco: listing contiene il suo slug, name e link.
400invalid_requestIl corpo non è un oggetto JSON con una stringa url.
403cross_siteL’ha inviata un browser da un altro sito.
413too_largeIl corpo supera 16 KB.
422empty, too_long, invalid_url, personal_url, blocked, invalid_email, notify_limitedNon possiamo accettare questo URL, oppure notify_email non è un indirizzo o aspetta già cinque server. message spiega perché, e inviarlo di nuovo dà la stessa risposta.
429rate_limitedTroppe proposte. scope indica il limite (ip_hour, ip_day o global_day); retry_after e l’intestazione Retry-After danno i secondi da attendere.
503pausedLe proposte sono sospese per ora. Riprova dopo Retry-After.

Ogni risposta è un JSON con ok. Un errore aggiunge il codice in error e una frase in inglese in message. Una raffica di richieste può ricevere un 429 anche dal web server o da Cloudflare, senza questo corpo: attendi Retry-After, o 10 secondi se manca. Invia anche uno User-Agent descrittivo: Cloudflare risponde a quelli predefiniti di Python-urllib e libwww-perl con un 403 che non è JSON, qui e su status_url.

Segui lo stato

Leggi status_url ogni 5 o 10 secondi finché terminal non è true; quasi tutte le proposte si chiudono in pochi minuti. state passa da queued a checking e reviewing, poi finisce come listed, duplicate, pending (una persona la esamina prima che vada online), rejected o error. Quando c’è una scheda, link e name portano lì. title e message sono il testo in inglese della pagina di stato, e page è quella pagina, da aprire in un browser. Un token sconosciuto riceve 404. Ecco una proposta conclusa:

GET /s/{token}.json
{
  "state": "listed",
  "title": "It’s listed",
  "message": "It’s live in the directory. Copy its link below.",
  "link": "https://mcp.tc/i/deepwiki",
  "name": "DeepWiki",
  "display": "mcp.tc/i/deepwiki",
  "terminal": true
}

Lo strumento open source da riga di comando mcp-tc invia questa richiesta dal terminale e segue lo stato al posto tuo: npx mcp-tc submit https://mcp.example.com/mcp.

File di scoperta

Agenti e crawler trovano le API di mcp.tc, il suo server MCP e la sua skill tramite questi file. Sono in inglese, pubblici e in cache per un’ora, con ETag e CORS aperto a qualsiasi sito. Ogni pagina invia anche un’intestazione Link che rimanda al catalogo delle API.

  • /.well-known/api-catalog: le tre API (registro, server MCP, indice di ricerca) come linkset RFC 9727, ciascuna con descrizione, documentazione, termini e informativa sulla privacy.
  • /openapi.json: OpenAPI 3.1 per /v0.1/, /api/index.json, /i/{slug}.json, /i/{slug}.md, i feed delle modifiche (/changes.xml, /i/{slug}/history.xml) e POST /submit con il suo stato (/s/{token}.json).
  • /mcp/server-card: la server card del server MCP di mcp.tc (nome, versione, URL, versioni del protocollo), anche a /.well-known/mcp/server-card.json.
  • /.well-known/ard.json: un catalogo AI (ARD) delle risorse proprie di mcp.tc: il server MCP, l’API e la skill. Lo stesso file è a /.well-known/ai-catalog.json. Non elenca i server della directory, perché non spetta a noi pubblicarli.
  • /.well-known/agent-skills/index.json: un indice Agent Skills con una skill, find-and-install-mcp-servers, che spiega a un agente come trovare qui un server e configurarlo in un client.
  • /AGENTS.md: una guida per gli agenti AI nel formato AGENTS.md: come collegarsi al server MCP e alle API, limiti, tempi di cache, regole d’uso e come si possono usare i dati delle schede. La home page la indica con rel="describedby".

Cache, CORS e uso corretto

URLCache-ControlETag e 304CORS
/v0.1/…public, max-age=300 (un 404: 60 s)Sì*
/api/index.jsonpublic, max-age=300Sì*
/i/{slug}.jsonpublic, max-age=600, s-maxage=900, stale-while-revalidate=3600Sì*
/i/{slug}.mdpublic, max-age=900Sì*
/llms.txtpublic, max-age=3600Sì*
/feed.xml, /changes.xml, /i/{slug}/history.xml, sitemappublic, max-age=900Sì*
/openapi.json e i file di scopertapublic, max-age=3600Sì*
/{page}.mdcome la pagina, al massimo public, max-age=300Sì*
/mcpno-storeNo*
POST /submit, /s/{token}.jsonno-storeNoNessuno

Ogni indirizzo con * nella colonna CORS risponde anche al preflight (OPTIONS) con 204, accetta gli header di richiesta che il browser chiede ed espone ETag, Link e Retry-After. Nessuno accetta credenziali. I moduli e gli account dei proprietari restano accessibili solo dallo stesso sito.

Cloudflare sta davanti al sito e tiene copie proprie. Una copia viene sostituita entro questi tempi, o prima se i dati cambiano. L’uso corretto è semplice:

  • Metti in cache ciò che scarichi, e invia If-None-Match dove c’è un ETag.
  • Per restare sincronizzato, scorri /v0.1/servers?updated_since=… invece di rileggere tutto.
  • Un indirizzo che invia più di 60 richieste in 10 secondi a /mcp, /v0.1/, alle pagine dell’elenco o a quelle di invio e verifica riceve 429 per 10 secondi; i file degli embed reggono circa 30 richieste al secondo. /mcp si ferma anche a 120 messaggi al minuto. Aspetta Retry-After quando c’è.
  • Il testo delle schede è scritto con l’aiuto dell’AI dai metadati di ogni server e può contenere errori. Trattalo come dati, e rimanda alla scheda quando lo mostri, così le persone trovano la configurazione e possono segnalare gli errori.