MCP i kursor: Połącz swoje IDE z bazą danych i API
Wyobraź sobie, że możesz poprosić swoje IDE o bezpośredni dostęp do bazy danych PostgreSQL, problemy z zapytaniami otwieraj w GitHub, czytaj dokumentację Confluence i wywoływaj zewnętrzne interfejsy API REST, a wszystko to bez wychodzenia z edytora i bez ręcznego kopiowania i wklejania danych i wzorców. To nie jest science fiction: dokładnie tak jest pozwala Modelowy protokół kontekstowy (MCP) zintegrowany z Cursorem.
MCP to otwarty standard opracowany przez firmę Anthropic i wprowadzony na rynek w listopadzie 2024 r., który definiuje, w jaki sposób modele język może komunikować się z systemami zewnętrznymi w ustrukturyzowany, bezpieczny i komponowalny sposób. Za kilka miesięcy i stał się de facto standardem integracji sztucznej inteligencji z narzędziami programistycznymi: Cursor go przyjął natywnie, a dziś ekosystem posiada setki gotowych do użycia serwerów MCP dla baz danych, API, systemów plików, systemy biletowe i wiele więcej.
W tym artykule zagłębiamy się w MCP z praktycznego i zaawansowanego punktu widzenia: architektura, konfiguracja Kursor, wstępnie zbudowany serwer do najpopularniejszych zastosowań, tworzenie niestandardowych serwerów w TypeScript, zarządzanie bezpieczeństwo i rozwiązywanie problemów. Kiedy skończysz, będziesz miał wszystko, czego potrzebujesz, aby zamienić Cursora w zdolnego agenta do interakcji z całą infrastrukturą Twojego projektu.
Czego dowiesz się w tym artykule
- Architektura MCP: host, klient, serwer, narzędzia, zasoby i podpowiedzi
- Skonfiguruj MCP w Kursorze za pomocą pliku
.cursor/mcp.json(projekt i zakres globalny) - Połącz Cursor z PostgreSQL, MySQL i SQLite poprzez serwer MCP
- Zintegruj interfejsy API REST, GraphQL, GitHub i Jira z wstępnie zbudowanymi serwerami MCP
- Utwórz niestandardowy serwer MCP w TypeScript za pomocą oficjalnego pakietu SDK
- Zarządzaj bezpieczeństwem, uprawnieniami i rotacją danych uwierzytelniających
- Diagnozuj i rozwiązuj najczęstsze problemy z połączeniem MCP
- Porównanie MCP z tradycyjnymi podejściami integracyjnymi
Warunki wstępne
- Zainstalowany kursor IDE (dla stabilnego MCP zalecana jest wersja 0.43+)
- Zainstalowano Node.js 18+ i npm
- Podstawowa znajomość TypeScriptu i JSON
- Opcjonalnie: dostępna baza danych PostgreSQL lub MySQL z praktycznymi przykładami
1. Co to jest protokół kontekstu modelu
Il Modelowy protokół kontekstowy (MCP) oraz otwarty standard oparty na JSON-RPC 2.0, który definiuje jak aplikacja AI (plik klient) może łączyć się z systemami zewnętrznymi (tj serwer) za uzyskuj kontekst, wykonuj działania i uzyskuj dostęp do zasobów w ustrukturyzowany sposób. I ten „wspólny język”. pozwala Cursorowi komunikować się z Twoją bazą danych w taki sam sposób, w jaki mógłby komunikować się z GitHubem i Jira lub dowolne inne API.
Przed MCP każde AI IDE wdrażało własne, zastrzeżone integracje: różne narzędzia, różne interfejsy API, różne formaty. Dzięki MCP raz napisany serwer współpracuje z Cursor, Claude Desktop, VS Code Copilot i dowolnego innego kompatybilnego klienta. To ta sama zasada, która uczyniła HTTP standardem sieciowym.
2. Architektura MCP: Host, Klient i Serwer
Architektura MCP jest podzielona na trzy poziomy, które należy zrozumieć przed jakąkolwiek konfiguracją integracja:
Trzy poziomy MCP
- Zastępy niebieskie: aplikacja, z którą użytkownik wchodzi w bezpośrednią interakcję. W tym przypadku kursor IDE. The host manages the lifecycle of MCP clients and orchestrates interactions with AI models.
- Klienci MCP: wewnętrzny komponent hosta, który utrzymuje połączenie 1:1 z pojedynczym Serwer MPK. Cursor automatycznie zarządza tworzeniem i obsługą klientów dla każdego serwera skonfigurowany.
- Serwer MCP: zewnętrzny (lub zdalny) proces udostępniający możliwości: narzędzia, zasoby i podpowiedzi. Może to być proces lokalny (stdio) lub usługa zdalna (HTTP/SSE).
Każdy serwer MCP udostępnia trzy typy prymitywów, których może używać klient:
// 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 }
]
}Komunikacja pomiędzy klientem a serwerem odbywa się poprzez JSON-RPC 2.0 poprzez jeden z obsługiwanych transportów:
- stdio (standardowe we/wy): klient uruchamia serwer jako proces potomny i komunikuje się za jego pośrednictwem stdin/stout. Oraz najprostszy i najbardziej odpowiedni transport dla lokalnych serwerów. Kursor automatycznie zarządza cykl życia procesu.
- Przesyłany strumieniowo protokół HTTP: serwer działa jako niezależna usługa HTTP. Idealny dla serwerów zdalnych współdzielone między wieloma programistami lub do integracji z chmurą. Od marca 2025 r. zastąpił SSE w transporcie Zalecany protokół HTTP.
Transport SSE jest przestarzały
Transport zdarzeń wysłanych przez serwer (SSE) został wycofany w specyfikacji MCP z 26 marca 2025 r. Jeśli jesteś
korzystając z istniejących konfiguracji SSE, migruj do formatu streamableHttp. Wersja kursora
Wersja 0.43+ obsługuje nową specyfikację.
3. Skonfiguruj MCP w Kursorze
Cursor obsługuje dwa zakresy konfiguracji MCP, które określają, gdzie są dostępne skonfigurowane serwery:
# 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 nomiPodstawowa struktura pliku konfiguracyjnego jest prosta i spójna pomiędzy obydwoma zakresami:
// .cursor/mcp.json - Struttura base
{
"mcpServers": {
"nome-server": {
"command": "comando-da-eseguire",
"args": ["argomento1", "argomento2"],
"env": {
"VARIABILE": "valore"
}
}
}
}W przypadku serwerów zdalnych za pośrednictwem protokołu HTTP struktura jest nieco inna:
// .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}}"
}
}
}
}
Po zapisaniu pliku konfiguracyjnego uruchom ponownie Cursor lub naciśnij Cmd/Ctrl + Shift + P i wyszukaj
„MCP: Załaduj ponownie serwery”, aby zastosować zmiany. Możesz sprawdzić status serwerów w
Ustawienia > MCP gdzie zobaczysz każdy serwer z zielonym (połączony) lub czerwonym (błąd) wskaźnikiem.
4. Serwer MCP dla bazy danych
Serwery baz danych MCP należą do najbardziej przydatnych dla programistów: umożliwiają to modelowi Cursor AI sprawdzaj schematy, wykonuj zapytania, analizuj wydajność i proponuj optymalizacje oparte na strukturze rzeczywistość Twojej bazy danych, a nie na ogólnych założeniach.
4.1 PostgreSQL
Oficjalny serwer MCP dla PostgreSQL firmy Anthropic udostępnia schemat bazy danych jako zasoby MCP i pozwala aby wykonać zapytania tylko do odczytu (tylko do odczytu ze względów bezpieczeństwa):
// .cursor/mcp.json - PostgreSQL server ufficiale
{
"mcpServers": {
"postgres": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-postgres",
"postgresql://utente:password@localhost:5432/mio_database"
]
}
}
}Nie umieszczaj poświadczeń w pliku konfiguracyjnym
Unikaj wprowadzania nazwy użytkownika i hasła bezpośrednio w adresie URL parametrów połączenia w pliku
mcp.json, zwłaszcza jeśli plik jest wersjonowany w git. Użyj zmiennych środowiskowych:
// .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=supersecretpasswordPo skonfigurowaniu możesz wchodzić w interakcję z bazą danych bezpośrednio z czatu Cursor:
Szybkie przykłady z PostgreSQL MCP
- „Pokaż schemat tabeli użytkowników i powiedz, czy brakuje ważnych indeksów”
- „Ile wierszy znajduje się w tabeli zamówień utworzonej w ciągu ostatniego miesiąca?”
- „Przeanalizuj to powolne zapytanie i zaproponuj optymalizacje w oparciu o prawdziwy schemat”
- „Wygeneruj migrację TypeORM, aby dodać kolumnę email_verified do tabeli użytkowników”
4.2 MySQL i MariaDB
Dla MySQL i MariaDB istnieją społecznościowe serwery MCP, które oferują podobną funkcjonalność:
// .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 dla rozwoju lokalnego
// .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. Serwer MCP dla API i usług zewnętrznych
Oprócz baz danych ekosystem MCP oferuje gotowe serwery umożliwiające integrację najpopularniejszych narzędzi z przepływem pracy codziennego rozwoju.
5.1 MCP GitHuba
Oficjalny serwer GitHub MCP (utrzymywany bezpośrednio przez GitHub) umożliwia zarządzanie repozytoriami, problemy, żądania ściągnięcia, przepływy pracy CI/CD i wiele więcej bezpośrednio z czatu Cursor:
// .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"
}
}
}
}Po skonfigurowaniu serwera GitHub Cursor może:
- Czytaj i twórz problemy oraz żądania ściągnięcia
- Analizuj historię zatwierdzeń, aby zrozumieć kontekst błędu
- Przeszukaj kod repozytoriów publicznych i prywatnych
- Wyzwalaj przepływ pracy akcji GitHub
- Czytaj i pisz komentarze na temat PR
5.2 Systemy plików MCP
Serwer systemu plików Anthropic umożliwia modelowi odczytywanie i zapisywanie plików w określonych ścieżkach, ze szczegółową kontrolą dostępu:
// .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 Konfiguracja wieloserwerowa
Potężny aspekt MCP w Cursor i możliwość konfiguracji wielu serwerów jednocześnie, łączenie baz danych, zewnętrznych API i narzędzi wewnętrznych w jednym pliku:
// .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. Utwórz niestandardowy serwer MCP w TypeScript
Gotowe serwery sprawdzają się w wielu typowych przypadkach użycia, ale często konieczne będzie podłączenie Cursora do systemów elementy wewnętrzne, zastrzeżone interfejsy API lub logikę specyficzną dla Twojego projektu. Oficjalny zestaw SDK TypeScript sprawia, że Zaskakująco proste tworzenie niestandardowego serwera.
6.1 Konfiguracja projektu
# 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 Podstawowy serwer MCP z narzędziami i zasobami
Zobaczmy, jak zbudować kompletny serwer MCP, który udostępnia narzędzia do wysyłania zapytań do wewnętrznego interfejsu API REST i zasoby umożliwiające eksponowanie danych statycznych:
// 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 Połącz serwer niestandardowy z kursorem
// 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"
}
}
}
}Wskazówka: używaj ścieżek bezwzględnych
W polu args pliku mcp.json, zawsze używaj bezwzględnych ścieżek do pliku
serwera. Kursor uruchamia procesy MCP w kontekstach, w których może nie znajdować się katalog roboczy
czego oczekujesz.
7. Bezpieczeństwo i zarządzanie danymi uwierzytelniającymi MCP
Security is probably the most critical aspect of implementing MCP in a professional context. Serwery MCP mają dostęp do wrażliwych zasobów (bazy danych, API, systemu plików) i błędnej konfiguracji może ujawnić krytyczne dane.
7.1 Zasada najmniejszego przywileju
Podstawową zasadą jest skonfigurowanie każdego serwera MCP z minimalnymi niezbędnymi uprawnieniami:
// 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 Bezpieczne zarządzanie zmiennymi środowiskowymi
// 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: Bezpieczeństwo MPoison i mcp.json
W 2025 roku udokumentowano lukę w zabezpieczeniach o nazwie „MCPoison” (CVE-2025-54136) wpływającą na Cursor:
Gdy serwer MCP zostanie zatwierdzony przez użytkownika, Cursor kojarzy zaufanie z nazwa
serwera, a nie rozkaz. Plik mcp.json zmodyfikowany przez atakującego w
współdzielone repozytorium mogłoby zastąpić polecenie wykonane przy zachowaniu tej samej zaufanej nazwy.
MCŚrodki łagodzenia zatruć
- Nie angażuj się
.cursor/mcp.jsonz poświadczeniami we współdzielonych repozytoriach - Dodać
.cursor/mcp.jsonal.gitignorejeśli zawiera dane uwierzytelniające - Użyj konfiguracji globalnej (
~/.cursor/mcp.json) w celu uzyskania osobistych danych uwierzytelniających - Regularnie aktualizuj Cursor: nowsze wersje usprawniają zarządzanie zaufaniem
- Zawsze sprawdzaj zawartość
mcp.jsonpo pobraniu ze wspólnych repozytoriów
# .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. Rozwiązywanie problemów z połączeniami MCP
MCP to stosunkowo młoda technologia i problemy z połączeniem są powszechne, szczególnie w trakcie wstępna konfiguracja. Oto systematyczny przewodnik po diagnozowaniu i rozwiązywaniu najczęstszych problemów.
8.1 Sprawdź status serwerów
Pierwszym krokiem jest zawsze sprawdzenie statusu serwerów z poziomu interfejsu Cursor:
- Otwarte Ustawienia (Cmd/Ctrl + ,)
- Przejdź do sekcji MCP w panelu bocznym
- Każdy serwer pokazuje wskaźnik: zielony (połączony), żółty (łączenie), czerwony (błąd)
- Kliknij ikonę dziennika obok uszkodzonego serwera, aby wyświetlić komunikaty o błędach
8.2 Typowe problemy i rozwiązania
// 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 Włącz debugowanie 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 a podejścia tradycyjne
Aby zrozumieć prawdziwą wartość MCP, warto porównać je z tradycyjnymi podejściami do integracji pomiędzy sztuczną inteligencją a narzędziami zewnętrznymi:
| Czekam | Tradycyjne podejście | MCP |
|---|---|---|
| Integracja | Ręcznie skopiuj i wklej schemat/dane do czatu | Bezpośredni i zorganizowany dostęp w czasie rzeczywistym |
| Normalizacja | Każde IDE ma niekompatybilne, zastrzeżone wtyczki | Jeden serwer współpracuje ze wszystkimi klientami MCP |
| Bezpieczeństwo | Poświadczenia w monitach lub w kontekście czatu | Poświadczenia w procesie serwera, nigdy nie udostępniane modelowi |
| Możliwość komponowania | Integracje izolowane, trudne do połączenia | Wiele serwerów można połączyć w jednym przepływie pracy |
| Konserwacja | Dowolna niestandardowa integracja do utrzymania | Utrzymywany ekosystem serwerów społecznościowych |
| Aktualizacje danych | Dane statyczne w (statycznym) kontekście | Dostęp na żywo do aktualnych danych |
10. Praktyczny przebieg pracy: MCP z projektem Angular
Zobaczmy, jak MCP zmienia przepływ pracy w projekcie Angular z backendem PostgreSQL, łączenie wielu serwerów w jedną konfigurację operacyjną:
// .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"
}
}
}
}Gdy ta konfiguracja jest aktywna, podpowiedzi, których można używać w Kursorze, stają się znacznie potężniejsze:
Zaawansowane podpowiedzi w przypadku wielu serwerów MCP
- „Spójrz na problem nr 142 w GitHub i zaimplementuj żądaną funkcję. Schemat bazy danych jest gotowy postgres/my_db, odpowiednia tabela nazywa się subskrypcjami.”
- „Napisz testy E2E dla komponentu UserList. Do wygenerowania użyj aktualnego schematu bazy danych realistyczne dane testowe.”
- "There was a regression in commit abc1234. Compare the current schema with that one poprzednie i zidentyfikuj zmiany, które mogły spowodować problem.
- „Wygeneruj plik migracji TypeORM, aby dodać niezbędne kolumny do tabeli użytkowników, w oparciu o aktualną strukturę bazy danych.”
11. Najlepsze praktyki dotyczące MCP w produkcji
Lista kontrolna MCP dla zespołów programistycznych
- Oddzielenie pomieszczeń: używać różnych serwerów MCP do celów deweloperskich, testowych i produkcyjnych, nigdy ten sam serwer MCP nie wskazuje na wiele środowisk
- Domyślnie tylko do odczytu: konfiguruje wszystkie serwery baz danych jako tylko do odczytu; umożliwia zapis tylko na serwerach dedykowanych i za podwójnym potwierdzeniem
- Rotacja klawiszy: ustawić datę ważności tokenów API używanych przez serwery MCP; 60-90 dni to dobra praktyka
-
Gitignore dla mcp.json: nigdy nie wersjonowane pliki z poświadczeniami; USA
mcp.json.examplejako udostępniony szablon - Monitorowanie: wdrożyć logowanie strukturalne na niestandardowych serwerach w celu śledzenia które narzędzia są wywoływane i z której sesji kursora
- Limity czasu: dodaj limity czasu do wywołań API na serwerze, aby temu zapobiec Kursor czeka w nieskończoność
- Walidacja danych wejściowych: użyj Zoda lub podobnego, aby sprawdzić otrzymane parametry z narzędzi przed wykonaniem operacji
// 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);
}
});Wnioski
Model Context Protocol stanowi jakościowy skok w sposobie interakcji AI IDE infrastrukturę deweloperską. Zamiast pracować w oderwaniu od statycznych, ogólnych informacji, Kursor ze skonfigurowanym MCP staje się agentem zdolnym do wnioskowania o prawdziwym kontekście: schemacie aktualny stan Twojej bazy danych, otwarte zgłoszenia na GitHubie, konkretne konfiguracje Twojego projektu.
Widzieliśmy, jak skonfigurować MCP zarówno globalnie, jak i na poziomie projektu, jak korzystać z gotowych serwerów dla najczęstszych przypadków użycia (PostgreSQL, GitHub, system plików), jak budować niestandardowe serwery w TypeScript integrować autorskie systemy oraz jak w profesjonalny sposób zarządzać bezpieczeństwem i rozwiązywaniem problemów.
Naturalnym następnym krokiem jest połączenie MCP z innymi zaawansowanymi funkcjami Cursora: użyj MCP w trybie agenta, aby agent mógł wykonywać wieloetapowe operacje wymagające dostępu do baza danych i repozytorium; użyj trybu planowania, aby zaplanować złożone elementy obejmujące wzór migracja i kod aplikacji razem. Możliwości ogromnie się mnożą.
Ekosystem MCP szybko się rozwija: co tydzień publikowane są nowe serwery na npm i w oficjalnym repozytorium Anthropic. Aby się tego dowiedzieć, warto regularnie przeglądać katalog nowe integracje, które mogą przyspieszyć Twoją pracę.
Powiązane artykuły z tej serii
- 01 - Cursor IDE: Kompletny przewodnik dla programistów
- 02 - Reguły kursora: Konfiguracja AI dla Twojego projektu
- 03 - Tryb agenta: Modyfikuj bazę kodu za pomocą polecenia
- 04 - Tryb planu i agenci w tle
- 05 – Zaczepy kursora: automatyzacja przepływu pracy
- 07 - Debugowanie za pomocą kursora AI: 3x szybciej
- 08 – Kursor vs Windsurf vs Copilot w 2026 r
- 09 - Profesjonalny przebieg pracy: projekt kątowy z kursorem
Powiązane serie
- Seria MCP (ID 64-77): przeprowadzić dogłębną analizę Model Context Protocol, Zaawansowana architektura i wdrożenie dla wszystkich klientów MCP
- Nowoczesny Angular (ID 224-233): profesjonalny przepływ pracy Angular, jaki możesz ulepszyć dzięki integracji MCP opisanej w tym artykule
- Kodowanie Vibe (ID 281-288): Podejście do rozwoju oparte na sztucznej inteligencji, doskonale uzupełnienie zaawansowanego wykorzystania Kursora z MCP