Tutoriel MCP : configurer Cursor pour interroger bases de données et API

Mercredi après-midi, je développais une fonctionnalité d’analyse de données et j’avais besoin de savoir combien d’utilisateurs avaient été ajoutés en décembre. Comme d’habitude, j’aurais dû basculer sur DataGrip, écrire une requête SQL, l’exécuter, copier le résultat et le coller dans le code. Pour une simple requête, j’ai changé de fenêtre trois fois — deux minutes perdues.

Puis j’ai réalisé : j’utilise Cursor tous les jours, l’IA m’aide déjà à écrire des fonctions et corriger des bugs — pourquoi ne pourrait-elle pas interroger la base directement ?

Après avoir configuré MCP, je demande simplement dans Cursor : « Combien d’utilisateurs ajoutés en décembre ? » — réponse instantanée. Plus de changement de fenêtre, plus de SQL à écrire à la main. L’efficacité a doublé.

Au début, quand j’ai entendu parler de MCP, j’étais perdu. Server, Client, Protocol — ça sonne impressionnant, mais les tutos en ligne sont soit trop théoriques (des diagrammes d’architecture pendant des pages), soit trop légers (un Hello World et c’est fini). J’ai mis deux jours à comprendre la configuration.

Cet article vous guide pas à pas pour configurer MCP et laisser l’IA interroger des bases de données et appeler des API. Quinze minutes de setup, et vous pouvez l’utiliser tout de suite.

Qu’est-ce que MCP et pourquoi en avoir besoin

MCP en langage clair

MCP signifie Model Context Protocol (protocole de contexte de modèle). Ça sonne académique, mais en réalité c’est une « ceinture à outils » pour l’IA.

Avant, l’IA ressemblait à un conseiller très intelligent : vous posez une question, elle propose des idées et écrit du code, mais ne peut rien exécuter elle-même. Vous copiez ses suggestions et vous les appliquez.

Avec MCP, l’IA devient un vrai assistant : elle peut interroger une base, appeler une API, lire des fichiers — tout seule.

Méthode classique vs MCP

Exemple concret : vous voulez le produit au chiffre d’affaires le plus élevé le mois dernier.

Méthode classique (sans MCP) :

1. Vous : demandez à l’IA d’écrire une requête SQL
2. L’IA : vous donne le SQL
3. Vous : copiez, basculez vers le client base de données
4. Vous : collez, exécutez
5. Vous : copiez le résultat
6. Vous : revenez dans Cursor, collez le résultat à l’IA
7. L’IA : analyse à partir du résultat

Trois fenêtres, des allers-retours — pénible.

Avec MCP :

1. Vous : « Quel produit a eu le plus gros CA le mois dernier ? »
2. L’IA : interroge la base et vous donne la réponse

Une seule étape. Au moins cinq fois plus rapide.

Concepts clés (3 minutes)

L’architecture MCP est simple — trois rôles :

MCP Client (le cerveau IA qui utilise les outils)
C’est votre outil IA : Cursor, Claude Desktop. Il comprend votre demande et décide s’il faut utiliser un outil.

MCP Server (le serveur qui fournit les outils)
Un service que vous configurez pour donner une capacité à l’IA. Un MCP Server base de données permet d’interroger la base ; un MCP Server API permet d’appeler des interfaces.

Tools (les capacités concrètes)
Les fonctions exposées par chaque MCP Server. Par exemple : « lister les tables », « exécuter un SELECT », « compter les lignes ».

Analogie : l’IA est l’ouvrier (Client), le MCP Server est la boîte à outils avec clé et marteau (Tools). Vous dites « enfoncer un clou », l’IA prend le marteau.

Une fois ces trois notions comprises, la configuration devient claire.

Cas pratique 1 — Intégration SQLite

Pourquoi commencer par SQLite

SQLite est simple : pas de service à installer, pas de port à configurer — un fichier = une base. Idéal pour s’entraîner.

Une fois le flux maîtrisé, PostgreSQL ou MySQL suivent la même logique.

🔥 Ne perdez plus des mois sur des produits sans demande ! Validez vos promesses SaaS avec Adsterra à petit budget →

Tester l'MVP →Pub

Préparation : créer une base de test

Créons des données pour tester les requêtes. Fichier test.db :

-- 创建用户表
CREATE TABLE users (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL,
    email TEXT UNIQUE,
    created_at TEXT DEFAULT CURRENT_TIMESTAMP
);

-- 创建订单表
CREATE TABLE orders (
    id INTEGER PRIMARY KEY,
    user_id INTEGER,
    product_name TEXT,
    amount REAL,
    order_date TEXT DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (user_id) REFERENCES users(id)
);

-- 插入测试用户
INSERT INTO users (name, email) VALUES
    ('张三', '[email protected]'),
    ('李四', '[email protected]'),
    ('王五', '[email protected]');

-- 插入测试订单
INSERT INTO orders (user_id, product_name, amount) VALUES
    (1, 'MacBook Pro', 12999.00),
    (1, 'AirPods', 1299.00),
    (2, 'iPhone 15', 5999.00),
    (3, 'iPad Air', 4799.00),
    (3, 'Apple Watch', 2999.00);

Exécutez ces SQL avec n’importe quel outil SQLite (DB Browser, ligne de commande) ou avec Python :

import sqlite3

conn = sqlite3.connect('test.db')
cursor = conn.cursor()

# 执行上面的SQL语句
# ...

conn.commit()
conn.close()

Configurer le MCP Server (partie centrale)

C’est le cœur du tutoriel. Deux emplacements possibles pour la configuration :

Configuration globale (tous les projets) :

• Windows : C:\Users\VotreNom\.cursor\mcp.json
• Mac/Linux : ~/.cursor/mcp.json

Configuration projet (projet courant uniquement) :

• .cursor/mcp.json à la racine du projet

Je recommande de commencer en configuration projet, puis de passer au global une fois que tout fonctionne.

Créez .cursor/mcp.json :

{
  "mcpServers": {
    "sqlite": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sqlite",
        "--db-path",
        "D:/path/to/your/test.db"
      ]
    }
  }
}

Points clés (où beaucoup bloquent) :

1. mcpServers : nom de champ fixe, ne pas modifier
2. "sqlite" : nom que vous donnez à ce serveur — l’IA le verra
3. command: "npx" : lance le MCP Server via npx, sans installation manuelle
4. args : arguments passés à la commande
   • -y : confirme l’installation automatiquement
   • @modelcontextprotocol/server-sqlite : package officiel SQLite MCP Server
   • --db-path : chemin du fichier base (doit être un chemin absolu !)

Sous Windows : utilisez des barres obliques / ou des doubles antislashs \\, pas un antislash simple :

• ✅ D:/projects/test.db
• ✅ D:\\projects\\test.db
• ❌ D:\projects\test.db (provoque une erreur)

Redémarrer Cursor et valider

Après avoir enregistré la config, redémarrez Cursor complètement — quittez l’application, pas seulement la fenêtre.

Ensuite, vérifiez dans les réglages :

1. Ouvrir les réglages (Ctrl+,)
2. Rechercher « MCP »
3. Votre serveur SQLite doit apparaître

Ou plus direct : posez une question liée à la base et voyez si l’IA appelle MCP.

Démonstration

Une fois configuré :

Requête 1 : lister les tables

Vous : Quelles tables dans la base ?
IA : [appel MCP] Deux tables : users et orders

Requête 2 : compter les utilisateurs

Vous : Combien d'utilisateurs au total ?
IA : [SELECT COUNT(*) FROM users] 3 utilisateurs

Requête 3 : commandes d’un utilisateur

Vous : Qu'a acheté 张三 ?
IA : [jointure] 张三 a acheté :
- MacBook Pro (12999元)
- AirPods (1299元)
Total : 14298元

Requête 4 : analyse agrégée

Vous : Quel utilisateur a le plus dépensé ?
IA : [GROUP BY] 张三, total 14298元

Sans écrire de SQL — l’IA s’en charge. C’est la force de MCP.

Dépannage courant

Problème 1 : le MCP Server ne démarre pas
Symptôme : l’IA répond sans interroger la base
Solutions :

• Vérifier la syntaxe JSON (pas de virgule en trop)
• Redémarrer Cursor complètement
• Consulter les logs de sortie, rechercher les erreurs « MCP »

Problème 2 : fichier base introuvable
Symptôme : « cannot open database file »
Solutions :

• Chemin absolu, pas relatif
• Sous Windows, vérifier le sens des barres
• Confirmer que le fichier existe (ls ou dir)

Problème 3 : erreur de permissions
Symptôme : Permission denied
Solutions :

• Vérifier les droits lecture/écriture du fichier
• Windows : clic droit → Propriétés → Sécurité, droits de lecture pour l’utilisateur courant

Astuce debug : dans Cursor, panneau « Output » (View → Output), canal « MCP » — logs détaillés.

Cas pratique 2 — Intégration PostgreSQL

Scénario avancé : base de production

SQLite convient à l’apprentissage et aux petits projets. En production, PostgreSQL ou MySQL sont plus courants. Bonne nouvelle : la logique de configuration est la même, seuls les paramètres changent.

Exemple avec PostgreSQL ; MySQL est similaire.

Différences : connexion et variables d’environnement

PostgreSQL est client/serveur — il faut fournir les informations de connexion. Ne mettez jamais le mot de passe en clair dans la config — erreur de sécurité très fréquente.

Utilisez des variables d’environnement.

Créez .env à la racine du projet (ajoutez-le à .gitignore) :

POSTGRES_HOST=localhost
POSTGRES_PORT=5432
POSTGRES_DATABASE=myapp
POSTGRES_USER=readonly_user
POSTGRES_PASSWORD=your_secure_password

Puis configurez .cursor/mcp.json :

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "--stdio"
      ],
      "env": {
        "POSTGRES_HOST": "${POSTGRES_HOST}",
        "POSTGRES_PORT": "${POSTGRES_PORT}",
        "POSTGRES_DATABASE": "${POSTGRES_DATABASE}",
        "POSTGRES_USER": "${POSTGRES_USER}",
        "POSTGRES_PASSWORD": "${POSTGRES_PASSWORD}"
      }
    }
  }
}

Points clés :

• --stdio : communication via entrée/sortie standard (mode local)
• env : variables d’environnement — Cursor lit le .env du projet

Bonnes pratiques de sécurité (très important)

Donner à l’IA l’accès à une base exige une vigilance maximale :

Vultr - Serveur cloud NVMe haute performance, 32 emplacements mondiaux, déploiement Docker en un clic

Voir les tarifs →Pub

1. Compte lecture seule

Pas de droits d’écriture ! Si l’IA interprète mal votre demande et exécute un DELETE ou UPDATE, les conséquences peuvent être graves.

Créer un utilisateur lecture seule :

-- 创建只读用户
CREATE USER readonly_user WITH PASSWORD 'secure_password';

-- 只给SELECT权限
GRANT CONNECT ON DATABASE myapp TO readonly_user;
GRANT USAGE ON SCHEMA public TO readonly_user;
GRANT SELECT ON ALL TABLES IN SCHEMA public TO readonly_user;

-- 确保将来新建的表也只有SELECT权限
ALTER DEFAULT PRIVILEGES IN SCHEMA public
GRANT SELECT ON TABLES TO readonly_user;

2. Limiter la portée

Pour les tables sensibles (mots de passe, paiements), retirez l’accès :

-- 撤销敏感表的访问权限
REVOKE SELECT ON TABLE user_passwords FROM readonly_user;
REVOKE SELECT ON TABLE payment_info FROM readonly_user;

3. Réplica en lecture en production

Si vous utilisez MCP en production (je déconseille au début), connectez-vous au moins à un réplica (Read Replica), pas au primary. Une requête trop lourde ne bloquera pas le service en ligne.

Démonstration

Après configuration, des requêtes impossibles avec SQLite seules :

Requête complexe : JOIN multi-tables

Vous : Salaire moyen par département
IA : [requête complexe]
SELECT d.name, AVG(e.salary) as avg_salary
FROM departments d
JOIN employees e ON d.id = e.department_id
GROUP BY d.name
ORDER BY avg_salary DESC;

Résultats :
- Tech : 15000元 en moyenne
- Produit : 12000元
- Ops : 10000元

Analyse de performance : plan d’exécution

Vous : Pourquoi cette requête est si lente ?
IA : [EXPLAIN] Pas d'index utilisé — suggestion d'index sur user_id

Analyse de données : rapport

Vous : Nouveaux utilisateurs par jour sur 7 jours
IA : [requête fenêtre temporelle]
2024-01-10 : 45
2024-01-11 : 52
...

Problèmes courants

Problème 1 : timeout de connexion
Symptôme : timeout connecting to database
Solutions :

• Vérifier que la base tourne (pg_isready)
• Pare-feu et règles réseau
• Host et port corrects

Problème 2 : échec d’authentification
Symptôme : authentication failed
Solutions :

• Identifiants corrects
• pg_hba.conf autorise l’utilisateur
• Test manuel avec psql

Problème 3 : permissions insuffisantes
Symptôme : permission denied for table xxx
Solutions :

• Peut indiquer que la lecture seule fonctionne comme prévu
• Si l’accès est nécessaire, exécuter les GRANT avec un compte admin

Cas pratique 3 — Intégration d’appels API

Cas d’usage : services externes

La base couvre les données internes ; parfois il faut des API externes :

• Stars et issues d’un dépôt GitHub
• Microservices internes
• Météo, taux de change, données temps réel

Avec MCP, l’IA peut aussi appeler ces interfaces.

Configurer un MCP Server de type HTTP

Les appels API diffèrent des bases : pas de package MCP à installer, configuration HTTP directe.

Exemple GitHub API, .cursor/mcp.json :

{
  "mcpServers": {
    "github-api": {
      "url": "https://api.github.com",
      "headers": {
        "Accept": "application/vnd.github.v3+json",
        "User-Agent": "Cursor-MCP-Client"
      }
    }
  }
}

Pour l’authentification (dépôts privés), ajoutez un token :

{
  "mcpServers": {
    "github-api": {
      "url": "https://api.github.com",
      "headers": {
        "Accept": "application/vnd.github.v3+json",
        "Authorization": "Bearer ${GITHUB_TOKEN}",
        "User-Agent": "Cursor-MCP-Client"
      }
    }
  }
}

Token dans .env :

GITHUB_TOKEN=ghp_your_personal_access_token_here

Obtenir un token GitHub :

1. GitHub → Settings → Developer settings
2. Personal access tokens → Tokens (classic)
3. Generate new token → cocher les permissions (repo, user, etc.)
4. Copier le token (affiché une seule fois)

Démonstration

Infos dépôt

Vous : Combien de stars pour facebook/react ?
IA : [GET /repos/facebook/react]
218 345 stars, 79 234 forks

Derniers issues

Vous : Quels issues récents sur facebook/react ?
IA : [GET /repos/facebook/react/issues?state=open&per_page=5]
5 derniers issues ouverts :
1. [Bug] useEffect exécuté deux fois en mode strict
2. [Feature] Nouvelle API Suspense
3. [Question] Optimiser le rendu de grandes listes
...

Fréquence de commits

Vous : Combien de commits la semaine dernière sur facebook/react ?
IA : [GET /repos/facebook/react/commits?since=...]
43 commits sur 7 jours, principaux contributeurs...

API interne personnalisée

Même principe pour une API d’entreprise. Exemple service utilisateurs :

{
  "mcpServers": {
    "user-service": {
      "url": "https://api.yourcompany.com/user-service",
      "headers": {
        "Authorization": "Bearer ${INTERNAL_API_KEY}",
        "Content-Type": "application/json"
      }
    }
  }
}

Puis :

Vous : Historique des commandes de l'utilisateur 12345
IA : [API interne] 8 commandes sur 30 jours, total 3200元

Points d’attention

Limitation de débit
Beaucoup d’API imposent des quotas. GitHub gratuit : 60 appels/heure. Des appels répétés déclenchent facilement le rate limiting.

Solutions :

Railway - Plateforme de déploiement moderne, sans opérations complexes, en ligne en quelques minutes

Commencer →Pub

• Token authentifié (GitHub : 5000/heure)
• Demander à l’IA de « limiter les appels API et réutiliser les résultats »

Risques de sécurité
Donner à l’IA l’accès API = lui confier des actions sur des services externes :

• Token lecture seule (pas d’écriture)
• Rotation régulière des tokens
• Surveillance des logs d’appels

Techniques avancées et bonnes pratiques

Plusieurs MCP Server simultanément

Vous pouvez configurer plusieurs serveurs. L’IA choisit l’outil adapté.

Exemple de configuration :

{
  "mcpServers": {
    "sqlite": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sqlite", "--db-path", "D:/projects/myapp/data.db"]
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "--stdio"],
      "env": {
        "POSTGRES_HOST": "${POSTGRES_HOST}",
        "POSTGRES_PORT": "${POSTGRES_PORT}",
        "POSTGRES_DATABASE": "${POSTGRES_DATABASE}",
        "POSTGRES_USER": "${POSTGRES_USER}",
        "POSTGRES_PASSWORD": "${POSTGRES_PASSWORD}"
      }
    },
    "github-api": {
      "url": "https://api.github.com",
      "headers": {
        "Authorization": "Bearer ${GITHUB_TOKEN}",
        "Accept": "application/vnd.github.v3+json"
      }
    }
  }
}

Ensuite :

Vous : Combien d'utilisateurs en SQLite local, et combien de stars sur notre dépôt GitHub ?
IA : [sqlite MCP] 245 utilisateurs locaux
    [github-api MCP] 1,2k stars

L’IA sélectionne l’outil selon la question.

Config projet vs globale

Configuration projet (.cursor/mcp.json) :

• Bases et API spécifiques au projet
• Avantage : isolation entre projets, versionnable (sans secrets)
• Inconvénient : à refaire par projet

Configuration globale (~/.cursor/mcp.json) :

• Outils génériques (système de fichiers, API communes)
• Avantage : une fois pour tous les projets
• Inconvénient : moins pratique en équipe

Recommandation :

• Bases, API projet → config projet
• GitHub, météo → config globale
• Documenter la config projet pour l’équipe

Optimisation des performances

Chaque appel MCP exécute une vraie requête ou un appel API — des appels fréquents ralentissent le flux.

1. Guider l’IA à mémoriser les résultats

Vous : Liste des utilisateurs (retiens ce résultat, je m'en servirai après)
IA : [requête et mémorisation] 245 utilisateurs...

Vous : Parmi ces 245, combien sont VIP ?
IA : [analyse sans nouvelle requête]

2. Limiter la complexité
Stoppez une requête SQL à 10 niveaux d’imbrication — optimisez manuellement.

3. Index en base
L’IA ne compense pas une base mal indexée.

Astuces de débogage

1. Logs MCP
Panneau Output → canal MCP :

• Démarrage des serveurs
• Paramètres et retours de chaque appel
• Stack traces d’erreur

2. Test simple après config

Vous : Teste la connexion base et dis-moi quelles tables existent

3. Vérification manuelle
Si l’IA échoue, exécutez vous-même pour distinguer SQL incorrect, permissions ou connexion.

Codes d’erreur courants

• ENOENT : fichier ou chemin introuvable
• ECONNREFUSED : connexion refusée (base arrêtée ou mauvais port)
• EACCES : permissions insuffisantes
• ERR_MODULE_NOT_FOUND : package MCP non installé (vérifier npx)
• ETIMEDOUT : timeout (réseau ou requête trop lente)

Conclusion

Après MCP, ma façon de coder a vraiment changé.

Avant, une simple requête impliquait trois fenêtres et cassait le fil de pensée. Maintenant, une question dans Cursor, réponse immédiate — le focus reste sur la logique.

Trois points essentiels :

1. Comprendre : MCP équipe l’IA d’outils pour agir, pas seulement conseiller
2. Configurer : SQLite pour s’entraîner, PostgreSQL en production, API pour étendre
3. Sécuriser : lecture seule, variables d’environnement, pas de primary en prod

Prenez 15 minutes aujourd’hui pour un MCP SQLite. Le gain n’est pas 10 ou 20 % — c’est une autre façon de travailler.

MCP évolue vite : l’officiel itère, la communauté ajoute des serveurs. J’ai une liste de MCP Servers sur GitHub — vous y trouverez peut-être l’outil qu’il vous faut.

Des questions ? Les commentaires sont ouverts — je réponds.