MCP și Cursor: Conectați-vă IDE la baza de date și la API
Imaginează-ți că poți cere IDE-ului tău să acceseze direct baza de date PostgreSQL, probleme de interogare deschideți pe GitHub, citiți documentația de la Confluence și apelați API-uri REST externe, totul fără a părăsi niciodată din editor și fără a copia și lipi manual datele și modelele. Nu este science fiction: exact asta este permite Model Context Protocol (MCP) integrat în Cursor.
MCP este un standard deschis dezvoltat de Anthropic și lansat în noiembrie 2024 care definește modul în care modelele de limbajul poate comunica cu sisteme externe într-un mod structurat, sigur și compus. În câteva luni şi a devenit standardul de facto pentru integrarea dintre AI și instrumentele de dezvoltare: Cursor l-a adoptat nativ, iar astăzi ecosistemul are sute de servere MCP gata de utilizare pentru baze de date, API-uri, sisteme de fișiere, sisteme de bilete și multe altele.
În acest articol ne aprofundăm în MCP din punct de vedere practic și avansat: arhitectură, configurare Cursor, server preconstruit pentru cele mai frecvente cazuri de utilizare, crearea de servere personalizate în TypeScript, gestionarea securitate și depanare. Când ați terminat, veți avea tot ce aveți nevoie pentru a transforma Cursor într-un agent capabil pentru a interacționa cu întreaga infrastructură a proiectului dumneavoastră.
Ce veți învăța în acest articol
- Arhitectura MCP: gazdă, client, server, instrumente, resurse și prompturi
- Configurați MCP în Cursor cu fișierul
.cursor/mcp.json(proiect și domeniu global) - Conectați Cursor la PostgreSQL, MySQL și SQLite prin serverul MCP
- Integrați API-urile REST, GraphQL, GitHub și Jira cu servere MCP prefabricate
- Creați un server MCP personalizat în TypeScript cu SDK-ul oficial
- Gestionați securitatea, permisiunile și rotația acreditărilor
- Diagnosticați și remediați cele mai frecvente probleme de conexiune MCP
- Comparație între MCP și abordările tradiționale de integrare
Cerințe preliminare
- IDE Cursor instalat (versiunea 0.43+ recomandată pentru MCP stabil)
- Node.js 18+ și npm instalate
- Cunoștințe de bază de TypeScript și JSON
- Opțional: o bază de date PostgreSQL sau MySQL accesibilă pentru exemple practice
1. Ce este Model Context Protocol
Il Model Context Protocol (MCP) și un standard deschis bazat pe JSON-RPC 2.0 care definește ca o aplicație AI (the client) se pot conecta la sisteme externe (de ex server) pentru obține context, efectuează acțiuni și accesează resurse într-un mod structurat. Iar „limbajul comun” care permite Cursorului să vorbească cu baza de date în același mod în care ar putea vorbi cu GitHub, Jira sau orice alt API.
Înainte de MCP, fiecare IDE AI și-a implementat propriile integrări proprietare: diferite instrumente, diferite API-uri, diferite formate. Cu MCP, un server scris odată funcționează cu Cursor, Claude Desktop, VS Code Copilot și orice alt client compatibil. Este același principiu care a făcut din HTTP standardul web.
2. Arhitectura MCP: gazdă, client și server
Arhitectura MCP este împărțită în trei niveluri care sunt esențiale de înțeles înainte de a configura orice integrare:
Cele trei niveluri MCP
- Gazde: aplicația cu care utilizatorul interacționează direct. În acest caz, Cursor IDE. Gazda gestionează ciclul de viață al clienților MCP și orchestrează interacțiunile cu modelele AI.
- Clienți MCP: componenta internă a gazdei care menține o conexiune 1:1 cu un singur Server MCP. Cursor gestionează automat crearea și întreținerea clienților pentru fiecare server configurat.
- Server MCP: proces extern (sau la distanță) care expune capabilități: instrumente, resurse și solicitări. Poate fi un proces local (stdio) sau un serviciu la distanță (HTTP/SSE).
Fiecare server MCP expune trei tipuri de primitive pe care clientul le poate folosi:
// Primitive MCP: overview concettuale
// 1. TOOLS - azioni che il modello può invocare
// (lettura/scrittura, chiamate API, esecuzione query)
{
"name": "execute_query",
"description": "Esegue una query SQL sul database",
"inputSchema": {
"type": "object",
"properties": {
"query": { "type": "string" }
},
"required": ["query"]
}
}
// 2. RESOURCES - dati che il modello può leggere
// (simili a endpoint GET di una REST API)
{
"uri": "postgres://mydb/tables",
"name": "Database Tables",
"description": "Lista di tutte le tabelle del database",
"mimeType": "application/json"
}
// 3. PROMPTS - template riutilizzabili
// (istruzioni pre-costruite per task comuni)
{
"name": "analyze_schema",
"description": "Analizza lo schema del database e suggerisce ottimizzazioni",
"arguments": [
{ "name": "table_name", "required": true }
]
}Comunicarea între client și server are loc prin JSON-RPC 2.0 prin unul dintre transporturile acceptate:
- stdio (I/O standard): clientul pornește serverul ca un proces copil și comunică prin stdin/stdout. Și cel mai simplu și mai potrivit transport pentru serverele locale. Cursorul gestionează automat ciclul de viață al procesului.
- HTTP transmisibil în flux: serverul rulează ca un serviciu HTTP independent. Ideal pentru servere la distanță partajat între mai mulți dezvoltatori sau pentru integrări în cloud. Din martie 2025 a înlocuit SSE ca transport HTTP recomandat.
Transport SSE este depreciat
Transportul evenimentelor trimise de server (SSE) a fost depreciat de specificația MCP din 26 martie 2025. Daca esti
folosind configurațiile SSE existente, migrați la format streamableHttp. Versiunea cursorului
0.43+ acceptă noua specificație.
3. Configurați MCP în Cursor
Cursorul acceptă două domenii de configurare MCP, care determină unde sunt disponibile serverele configurate:
# Configurazione GLOBALE (disponibile in tutti i progetti)
~/.cursor/mcp.json
# Configurazione PROGETTO (solo nel workspace corrente)
.cursor/mcp.json <-- nella root del progetto
# La configurazione progetto ha PRIORITA su quella globale
# in caso di conflitti di nomiStructura de bază a fișierului de configurare este simplă și consecventă între cele două domenii:
// .cursor/mcp.json - Struttura base
{
"mcpServers": {
"nome-server": {
"command": "comando-da-eseguire",
"args": ["argomento1", "argomento2"],
"env": {
"VARIABILE": "valore"
}
}
}
}Pentru serverele de la distanță prin HTTP, structura este ușor diferită:
// .cursor/mcp.json - Server remoto HTTP
{
"mcpServers": {
"nome-server-remoto": {
"url": "https://mio-server-mcp.example.com/mcp",
"headers": {
"Authorization": "Bearer {{env.MCP_API_TOKEN}}"
}
}
}
}
După salvarea fișierului de configurare, reporniți Cursorul sau apăsați Cmd/Ctrl + Shift + P și caută
„MCP: Reîncărcați serverele” pentru a aplica modificările. Puteți verifica starea serverelor în
Setări > MCP unde veți vedea fiecare server cu un indicator verde (conectat) sau roșu (eroare).
4. Server MCP pentru baza de date
Serverele de baze de date MCP sunt printre cele mai utile pentru dezvoltatori: permit modelului Cursor AI inspectează scheme, execută interogări, analizează performanța și sugerează optimizări bazate pe structură realitatea bazei de date, nu pe ipoteze generice.
4.1 PostgreSQL
Serverul MCP oficial pentru PostgreSQL de la Anthropic expune schema bazei de date ca resurse MCP și permite pentru a executa interogări numai în citire (numai în citire pentru securitate):
// .cursor/mcp.json - PostgreSQL server ufficiale
{
"mcpServers": {
"postgres": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-postgres",
"postgresql://utente:password@localhost:5432/mio_database"
]
}
}
}Nu puneți acreditările în fișierul de configurare
Evitați să introduceți numele de utilizator și parola direct în adresa URL a șirului de conexiune din fișier
mcp.json, mai ales dacă fișierul este versionat în git. Utilizați variabile de mediu:
// .cursor/mcp.json - PostgreSQL con variabili d'ambiente
{
"mcpServers": {
"postgres": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-postgres"
],
"env": {
"POSTGRES_CONNECTION_STRING": "postgresql://{{env.DB_USER}}:{{env.DB_PASSWORD}}@localhost:5432/mio_database"
}
}
}
}
# Nel tuo .env (NON versionato):
DB_USER=myuser
DB_PASSWORD=supersecretpasswordOdată configurat, puteți interacționa cu baza de date direct din cursor chat:
Exemple de prompt cu PostgreSQL MCP
- „Arată-mi schema tabelului utilizatori și spune-mi dacă lipsesc indecși importanți”
- „Câte rânduri există în tabelul de comenzi creat în ultima lună?”
- „Analizați această interogare lentă și sugerați optimizări bazate pe schema reală”
- „Generează o migrare TypeORM pentru a adăuga coloana email_verified la tabelul utilizatorilor”
4.2 MySQL și MariaDB
Pentru MySQL și MariaDB există servere MCP comunitare care oferă funcționalități similare:
// .cursor/mcp.json - MySQL tramite server community
{
"mcpServers": {
"mysql": {
"command": "npx",
"args": ["-y", "@benborla29/mcp-server-mysql"],
"env": {
"MYSQL_HOST": "localhost",
"MYSQL_PORT": "3306",
"MYSQL_USER": "root",
"MYSQL_PASS": "password",
"MYSQL_DB": "mio_database",
"ALLOW_INSERT_OPERATION": "false",
"ALLOW_UPDATE_OPERATION": "false",
"ALLOW_DELETE_OPERATION": "false"
}
}
}
}4.3 SQLite pentru Dezvoltare Locală
// .cursor/mcp.json - SQLite (ottimo per sviluppo locale e test)
{
"mcpServers": {
"sqlite": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-sqlite",
"--db-path",
"./database/dev.db"
]
}
}
}5. Server MCP pentru API-uri și servicii externe
Pe lângă bazele de date, ecosistemul MCP oferă servere prefabricate pentru a integra cele mai comune instrumente în fluxul de lucru de dezvoltare zilnică.
5.1 GitHub MCP
Serverul oficial GitHub MCP (menținut direct de GitHub) vă permite să gestionați depozitele, probleme, solicitări de extragere, fluxuri de lucru CI/CD și multe altele direct din chat-ul cursorului:
// .cursor/mcp.json - GitHub MCP ufficiale (via Docker)
// NOTA: Il package npm e stato deprecato ad aprile 2025
// Usa l'immagine Docker ufficiale:
{
"mcpServers": {
"github": {
"command": "docker",
"args": [
"run",
"--rm",
"-i",
"-e", "GITHUB_PERSONAL_ACCESS_TOKEN",
"ghcr.io/github/github-mcp-server"
],
"env": {
"GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_xxxxxxxxxxxx"
}
}
}
}
// Alternativa: via npx (versione community)
{
"mcpServers": {
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": {
"GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_xxxxxxxxxxxx"
}
}
}
}Cu serverul GitHub configurat, Cursor poate:
- Citiți și creați probleme și extrageți solicitări
- Analizați istoricul comitărilor pentru a înțelege contextul unei erori
- Căutați codul depozitelor publice și private
- Declanșează fluxul de lucru GitHub Actions
- Citiți și scrieți comentarii despre PR
5.2 Sisteme de fișiere MCP
Serverul sistemului de fișiere al lui Anthropic permite modelului să citească și să scrie fișiere pe căi specifice, cu control de acces granular:
// .cursor/mcp.json - Filesystem con accesso limitato
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-filesystem",
"/Users/federicocalo/progetti",
"/tmp/cursor-workspace"
]
}
}
}
// ATTENZIONE: specifica SOLO le directory necessarie
// Non dare accesso a / (root) o home directory completa5.3 Configurare multi-server
Un aspect puternic al MCP în Cursor și capacitatea de a configura mai multe servere simultan, combinând baze de date, API-uri externe și instrumente interne într-un singur fișier:
// .cursor/mcp.json - Configurazione completa multi-server
{
"mcpServers": {
// Database principale
"postgres-prod": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-postgres"],
"env": {
"POSTGRES_CONNECTION_STRING": "postgresql://user:pass@prod-db:5432/app"
}
},
// Database di sviluppo
"postgres-dev": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-postgres"],
"env": {
"POSTGRES_CONNECTION_STRING": "postgresql://user:pass@localhost:5432/app_dev"
}
},
// Repository GitHub
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": {
"GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_xxxx"
}
},
// Filesystem progetti
"filesystem": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-filesystem",
"/Users/federicocalo/progetti/mio-app"
]
},
// Server custom interno
"api-interna": {
"command": "node",
"args": ["/Users/federicocalo/mcp-servers/api-server/dist/index.js"],
"env": {
"API_BASE_URL": "https://api.mia-azienda.com",
"API_KEY": "key_xxxx"
}
}
}
}6. Creați un server MCP personalizat în TypeScript
Serverele preconstruite acoperă multe cazuri de utilizare obișnuite, dar deseori va trebui să conectați Cursor la sisteme interne, API-uri proprietare sau logica specifică proiectului dvs. SDK-ul oficial TypeScript face Creare de server personalizat surprinzător de simplă.
6.1 Configurarea proiectului
# Inizializza il progetto
mkdir mio-mcp-server
cd mio-mcp-server
npm init -y
# Installa le dipendenze
npm install @modelcontextprotocol/sdk zod
npm install -D typescript @types/node ts-node
# Configura TypeScript
npx tsc --init --target ES2022 --module commonjs --outDir dist// package.json - scripts necessari
{
"name": "mio-mcp-server",
"version": "1.0.0",
"main": "dist/index.js",
"scripts": {
"build": "tsc",
"start": "node dist/index.js",
"dev": "ts-node src/index.ts"
},
"dependencies": {
"@modelcontextprotocol/sdk": "^1.0.0",
"zod": "^3.22.0"
},
"devDependencies": {
"typescript": "^5.3.0",
"@types/node": "^20.0.0",
"ts-node": "^10.9.0"
}
}6.2 Server MCP de bază cu instrumente și resurse
Să vedem cum să construim un server MCP complet care să expună instrumente pentru a interoga un API REST intern și resurse pentru a expune date statice:
// src/index.ts - Server MCP completo
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
CallToolRequestSchema,
ListResourcesRequestSchema,
ListToolsRequestSchema,
ReadResourceRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";
import { z } from "zod";
const API_BASE_URL = process.env.API_BASE_URL || "https://api.esempio.com";
const API_KEY = process.env.API_KEY || "";
// Inizializza il server MCP
const server = new Server(
{
name: "mio-server-mcp",
version: "1.0.0",
},
{
capabilities: {
resources: {},
tools: {},
},
}
);
// === TOOLS ===
// I tools sono azioni che il modello può invocare
// Lista i tools disponibili
server.setRequestHandler(ListToolsRequestSchema, async () => {
return {
tools: [
{
name: "get_utenti",
description: "Recupera la lista degli utenti attivi dall'API",
inputSchema: {
type: "object",
properties: {
limite: {
type: "number",
description: "Numero massimo di utenti da restituire (default: 10)",
},
ruolo: {
type: "string",
enum: ["admin", "user", "guest"],
description: "Filtra per ruolo utente",
},
},
required: [],
},
},
{
name: "crea_report",
description: "Genera un report aggregato per un periodo specificato",
inputSchema: {
type: "object",
properties: {
data_inizio: {
type: "string",
format: "date",
description: "Data inizio periodo (YYYY-MM-DD)",
},
data_fine: {
type: "string",
format: "date",
description: "Data fine periodo (YYYY-MM-DD)",
},
tipo: {
type: "string",
enum: ["vendite", "utenti", "performance"],
description: "Tipo di report da generare",
},
},
required: ["data_inizio", "data_fine", "tipo"],
},
},
],
};
});
// Gestisce l'esecuzione dei tools
server.setRequestHandler(CallToolRequestSchema, async (request) => {
const { name, arguments: args } = request.params;
switch (name) {
case "get_utenti": {
const limite = (args?.limite as number) || 10;
const ruolo = args?.ruolo as string | undefined;
const url = new URL(`${API_BASE_URL}/utenti`);
url.searchParams.set("limite", String(limite));
if (ruolo) url.searchParams.set("ruolo", ruolo);
const response = await fetch(url.toString(), {
headers: { "X-API-Key": API_KEY },
});
if (!response.ok) {
throw new Error(`API error: ${response.status} ${response.statusText}`);
}
const data = await response.json();
return {
content: [
{
type: "text",
text: JSON.stringify(data, null, 2),
},
],
};
}
case "crea_report": {
const { data_inizio, data_fine, tipo } = args as {
data_inizio: string;
data_fine: string;
tipo: string;
};
const response = await fetch(`${API_BASE_URL}/report`, {
method: "POST",
headers: {
"Content-Type": "application/json",
"X-API-Key": API_KEY,
},
body: JSON.stringify({ data_inizio, data_fine, tipo }),
});
if (!response.ok) {
const errorText = await response.text();
throw new Error(`Errore report: ${response.status} - ${errorText}`);
}
const report = await response.json();
return {
content: [
{
type: "text",
text: `Report generato con successo:\n${JSON.stringify(report, null, 2)}`,
},
],
};
}
default:
throw new Error(`Tool sconosciuto: ${name}`);
}
});
// === RESOURCES ===
// Le resources espongono dati statici o semi-statici
server.setRequestHandler(ListResourcesRequestSchema, async () => {
return {
resources: [
{
uri: "config://ambiente",
name: "Configurazione Ambiente",
description: "Configurazione corrente dell'ambiente applicativo",
mimeType: "application/json",
},
{
uri: "docs://api-endpoints",
name: "Documentazione API",
description: "Lista di tutti gli endpoint API disponibili",
mimeType: "text/markdown",
},
],
};
});
server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
const { uri } = request.params;
switch (uri) {
case "config://ambiente":
return {
contents: [
{
uri,
mimeType: "application/json",
text: JSON.stringify(
{
ambiente: process.env.NODE_ENV || "development",
api_base_url: API_BASE_URL,
versione_api: "v2",
funzionalità: {
report: true,
export_csv: process.env.ENABLE_CSV === "true",
},
},
null,
2
),
},
],
};
case "docs://api-endpoints":
return {
contents: [
{
uri,
mimeType: "text/markdown",
text: `# Endpoint API Disponibili
## Utenti
- GET /utenti - Lista utenti
- GET /utenti/:id - Dettaglio utente
- POST /utenti - Crea utente
## Report
- POST /report - Genera report
- GET /report/:id - Scarica report
## Autenticazione
Tutti gli endpoint richiedono l'header X-API-Key.`,
},
],
};
default:
throw new Error(`Risorsa non trovata: ${uri}`);
}
});
// Avvia il server con trasporto stdio
async function main() {
const transport = new StdioServerTransport();
await server.connect(transport);
// Log su stderr (non stdout) per non corrompere il protocollo
console.error("Server MCP avviato e in ascolto");
}
main().catch((error) => {
console.error("Errore fatale:", error);
process.exit(1);
});6.3 Conectați serverul personalizat la Cursor
// Prima compila il server
// npm run build
// .cursor/mcp.json - Registra il server custom
{
"mcpServers": {
"api-interna": {
"command": "node",
"args": ["/percorso/assoluto/mio-mcp-server/dist/index.js"],
"env": {
"API_BASE_URL": "https://api.mia-azienda.com",
"API_KEY": "chiave_segreta_qui",
"NODE_ENV": "production"
}
}
}
}Sfat: Folosiți căi absolute
În câmp args a dosarului mcp.json, folosiți întotdeauna căi absolute către fișier
a serverului. Cursorul rulează procese MCP în contexte în care directorul de lucru poate să nu fie
ceea ce te astepti.
7. Securitatea și gestionarea acreditărilor MCP
Securitatea este probabil cel mai critic aspect al implementării MCP într-un context profesional. Serverele MCP au acces la resurse sensibile (bază de date, API, sistem de fișiere) și configurare greșită poate expune date critice.
7.1 Principiul celui mai mic privilegiu
Principiul fundamental este configurarea fiecărui server MCP cu permisiunile minime necesare:
// SBAGLIATO: credenziali admin sul database
{
"postgres": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-postgres",
"postgresql://postgres:adminpassword@localhost/db"
]
}
}
// CORRETTO: utente dedicato in sola lettura
// Prima crea l'utente sul database:
// CREATE USER cursor_readonly WITH PASSWORD 'password';
// GRANT CONNECT ON DATABASE db TO cursor_readonly;
// GRANT USAGE ON SCHEMA public TO cursor_readonly;
// GRANT SELECT ON ALL TABLES IN SCHEMA public TO cursor_readonly;
{
"postgres": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-postgres",
"postgresql://cursor_readonly:password@localhost/db"
]
}
}7.2 Managementul sigur al variabilelor de mediu
// APPROCCIO 1: Variabili d'ambiente di sistema
// Imposta le variabili nell'ambiente shell prima di avviare Cursor
# ~/.zshrc o ~/.bashrc
export POSTGRES_URL="postgresql://user:pass@localhost/db"
export GITHUB_TOKEN="ghp_xxxxxxxxxxxx"
export OPENAI_API_KEY="sk-xxxxxxxxxxxx"
// Nel mcp.json usa i riferimenti alle variabili:
{
"mcpServers": {
"postgres": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-postgres"],
"env": {
"POSTGRES_URL": "${POSTGRES_URL}"
}
}
}
}
// APPROCCIO 2: File .env locale (NON committato)
// .cursor/mcp.json legge automaticamente le variabili
// dall'ambiente del processo Cursor, che a sua volta
// può essere configurato da un .env nel progetto
// APPROCCIO 3: Secret manager (produzione/team)
// Usa 1Password CLI, Vault o AWS Secrets Manager:
{
"mcpServers": {
"postgres": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-postgres"],
"env": {
"POSTGRES_URL": "op://vault/database/connection-string"
}
}
}
}7.3 CVE-2025-54136: Securitate MCPoison și mcp.json
În 2025, a fost documentată o vulnerabilitate numită „MCPoison” (CVE-2025-54136) care afectează Cursorul:
Odată ce un server MCP este aprobat de către utilizator, Cursor asociază încrederea cu nume
a serverului, nu a comanda. Un dosar mcp.json modificat de un atacator în
depozitul partajat ar putea înlocui comanda executată, păstrând același nume de încredere.
Măsuri de atenuare a MCPoison
- Nu te angajezi
.cursor/mcp.jsoncu acreditări în arhivele partajate - Adăuga
.cursor/mcp.jsonal.gitignoredacă conține acreditări - Utilizați configurația globală (
~/.cursor/mcp.json) pentru acreditările dumneavoastră personale - Actualizați cursorul în mod regulat: versiunile mai noi îmbunătățesc gestionarea încrederii
- Verificați întotdeauna conținutul
mcp.jsondupă o extragere din depozitele partajate
# .gitignore - Aggiungi questa riga
.cursor/mcp.json
# Oppure usa un file template senza credenziali:
# .cursor/mcp.json.example (versionato, senza segreti)
# .cursor/mcp.json (ignorato da git, con segreti reali)8. Depanarea conexiunilor MCP
MCP este o tehnologie relativ tânără și problemele de conectare sunt frecvente, mai ales în timpul configurația inițială. Iată un ghid sistematic pentru diagnosticarea și rezolvarea celor mai frecvente probleme.
8.1 Verificați starea serverelor
Primul pas este întotdeauna să verificați starea serverelor din UI Cursor:
- Deschide Setări (Cmd/Ctrl + ,)
- Accesați secțiunea MCP în panoul lateral
- Fiecare server afișează un indicator: verde (conectat), galben (conectare), roșu (eroare)
- Faceți clic pe pictograma jurnal de lângă serverul eșuat pentru a vizualiza mesajele de eroare
8.2 Probleme și soluții comune
// PROBLEMA 1: "Server non trovato" o "command not found"
// CAUSA: Il comando npx/node non e nel PATH di Cursor
// SOLUZIONE: Usa il percorso assoluto del comando
// SBAGLIATO:
{ "command": "npx", "args": ["-y", "@mcp/server-postgres"] }
// CORRETTO (trova il percorso con 'which npx'):
{ "command": "/usr/local/bin/npx", "args": ["-y", "@mcp/server-postgres"] }
// ---
// PROBLEMA 2: "Connection refused" o "ECONNREFUSED"
// CAUSA: Il server SSE non e in esecuzione o porta sbagliata
// SOLUZIONE: Verifica che il server sia avviato e usa il trasporto corretto
// Per server stdio, non serve nessun server avviato separatamente
// Cursor lo avvia automaticamente come processo figlio
// ---
// PROBLEMA 3: JSON malformato nel mcp.json
// CAUSA: Virgola finale, commenti JS, ecc.
// MCP.json e JSON standard: NO commenti, NO trailing commas
// SOLUZIONE: Valida il JSON con jq:
// cat .cursor/mcp.json | jq .
// ---
// PROBLEMA 4: Variabili d'ambiente non disponibili
// CAUSA: Cursor non eredita le variabili dell'ambiente shell
// SOLUZIONE: Specifica esplicitamente le variabili nel campo "env"
{
"env": {
"MY_VAR": "valore-diretto"
}
}
// ---
// PROBLEMA 5: Output su stdout corrompe il protocollo
// CAUSA: Il server MCP usa console.log() invece di console.error()
// SOLUZIONE: Usa SEMPRE console.error() per i log nei server stdio
// Il protocollo MCP usa stdout per i messaggi JSON-RPC
// Qualsiasi output non-JSON su stdout rompe la comunicazione8.3 Activați depanarea MCP
# Modalità debug per MCP in Cursor
# Avvia Cursor da terminale con debug abilitato:
cursor --enable-mcp-logging --log-level=DEBUG
# Variabili d'ambiente per debug del server MCP:
export MCP_DEBUG=1
export MCP_LOG_LEVEL=debug
export DEBUG="mcp:*"
# Testa il server MCP manualmente (fuori da Cursor):
echo '{"jsonrpc":"2.0","method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}},"id":1}' | node dist/index.js9. MCP vs abordări tradiționale
Pentru a înțelege valoarea reală a MCP, este util să o comparăm cu abordările tradiționale de integrare între AI și instrumente externe:
| astept | Abordare tradițională | MCP |
|---|---|---|
| Integrare | Copiați și inserați manual schema/datele în chat | Acces direct și structurat în timp real |
| Standardizare | Fiecare IDE are pluginuri proprietare incompatibile | Un server funcționează cu toți clienții MCP |
| Siguranţă | Acreditări în solicitări sau în context de chat | Acreditări în procesul serverului, niciodată expuse modelului |
| Composabilitate | Integrari izolate, greu de combinat | Mai multe servere pot fi combinate într-un singur flux de lucru |
| Întreţinere | Orice integrare personalizată de menținut | Ecosistem de server comunitar întreținut |
| Actualizări de date | Date statice în context (static). | Acces live la date actualizate |
10. Flux de lucru practic: MCP cu un proiect angular
Să vedem cum MCP transformă fluxul de lucru de dezvoltare pe un proiect Angular cu backend PostgreSQL, combinând mai multe servere într-o singură configurație operațională:
// .cursor/mcp.json - Configurazione per progetto Angular + PostgreSQL
{
"mcpServers": {
"database": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-postgres",
"postgresql://cursor_ro:pass@localhost:5432/angular_app"
]
},
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": {
"GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_xxxx"
}
}
}
}Cu această configurație activă, solicitările pe care le puteți utiliza în Cursor devin mult mai puternice:
Solicitări avansate cu MCP Multi-Server
- „Uitați-vă la problema #142 pe GitHub și implementați caracteristica solicitată. Schema bazei de date este în postgres/my_db, tabelul implicat se numește abonamente."
- "Write E2E tests for UserList component. Use actual database schema to generate date de testare realiste.”
- „A existat o regresie în commit abc1234. Comparați schema actuală cu cea anterioare și identificați modificările care ar fi putut cauza problema."
- „Generează fișierul de migrare TypeORM pentru a adăuga coloanele necesare la tabelul utilizatorilor, bazată pe structura actuală a bazei de date.”
11. Cele mai bune practici pentru MCP în producție
Lista de verificare MCP pentru echipele de dezvoltare
- Separarea camerei: utilizați diferite servere MCP pentru dezvoltare, punere în scenă și producție, Același server MCP nu indică niciodată mai multe medii
- Implicit numai citire: configurează toate serverele de baze de date ca doar pentru citire; permite scrierea doar pe servere dedicate și cu dublă confirmare
- Rotirea tastelor: setați expirarea token-urilor API utilizate de serverele MCP; 60-90 de zile este o practică bună
-
Gitignore pentru mcp.json: fișiere nu au versiunea niciodată cu acreditări; STATELE UNITE ALE AMERICII
mcp.json.exampleca șablon partajat - Monitorizare: implementați înregistrarea structurată în servere personalizate pentru urmărire ce instrumente sunt invocate și din ce sesiune Cursor
- Timeouts: adăugați timeout-uri la apelurile API de pe server pentru a preveni acest lucru Cursorul așteaptă la nesfârșit
- Validarea intrărilor: utilizați Zod sau similar pentru a valida parametrii primiți din scule înainte de a efectua operațiuni
// Esempio: Tool con validazione Zod e timeout
import { z } from "zod";
const QuerySchema = z.object({
tabella: z.string().min(1).max(100).regex(/^[a-zA-Z_][a-zA-Z0-9_]*$/),
limite: z.number().int().positive().max(1000).default(50),
filtro: z.string().optional(),
});
// Nel handler del tool:
server.setRequestHandler(CallToolRequestSchema, async (request) => {
const parsed = QuerySchema.safeParse(request.params.arguments);
if (!parsed.success) {
throw new Error(`Parametri non validi: ${parsed.error.message}`);
}
// AbortController per timeout
const controller = new AbortController();
const timeoutId = setTimeout(() => controller.abort(), 10000); // 10s timeout
try {
const result = await fetch(apiUrl, {
signal: controller.signal,
headers: { "X-API-Key": API_KEY },
});
return { content: [{ type: "text", text: await result.text() }] };
} finally {
clearTimeout(timeoutId);
}
});Concluzii
Protocolul de context model reprezintă un salt calitativ în modul în care interacționează cu IDE-urile AI infrastructura de dezvoltare. În loc să lucrezi izolat cu informații statice, generice, Cursorul cu MCP configurat devine un agent capabil să raționeze despre contextul tău real: schema starea curentă a bazei de date, probleme deschise pe GitHub, configurații specifice ale proiectului.
Am văzut cum se configurează MCP atât la nivel global, cât și la nivel de proiect, cum se utilizează servere prefabricate pentru cele mai frecvente cazuri de utilizare (PostgreSQL, GitHub, sistem de fișiere), cum să construiți servere personalizate în TypeScript pentru a integra sistemele proprietare și cum să gestionați securitatea și depanarea într-un mod profesional.
Următorul pas natural este să combinați MCP cu alte caracteristici avansate ale Cursor: utilizați MCP în modul Agent pentru a determina agentul să efectueze operațiuni în mai mulți pași care necesită acces la bază de date și depozit; utilizați Modul Plan pentru a planifica caracteristici complexe care implică modele migrarea și codul aplicației împreună. Posibilitățile se înmulțesc enorm.
Ecosistemul MCP crește rapid: noi servere sunt publicate în fiecare săptămână pe npm și pe depozitul oficial antropic. Merită să explorați periodic catalogul pentru a afla noi integrări care vă pot accelera fluxul de lucru.
Articole similare din această serie
- 01 - Cursor IDE: Ghid complet pentru dezvoltatori
- 02 - Reguli cursor: Configurarea AI pentru proiectul dvs
- 03 - Modul agent: Modificați baza de cod cu o comandă
- 04 - Modul Plan și agenți de fundal
- 05 - Cârlige de cursor: Automatizați fluxul de lucru
- 07 - Depanare cu Cursor AI: de 3x mai rapid
- 08 - Cursor vs Windsurf vs Copilot în 2026
- 09 - Flux de lucru profesional: Proiect unghiular cu cursor
Serii înrudite
- Seria MCP (ID-uri 64-77): să completeze un studiu aprofundat asupra modelului de protocol de context, Arhitectură avansată și implementare pentru toți clienții MCP
- Angular modern (ID-urile 224-233): Flux de lucru profesional Angular pe care îl puteți îmbunătățiți cu integrările MCP văzute în acest articol
- Codare Vibe (ID-uri 281-288): AI-prima abordare a dezvoltării, perfect complementar cu utilizarea avansată a Cursorului cu MCP