Vous utilisez Claude Code au quotidien pour coder plus vite, mais il reste deconnecte de votre ecosysteme interne. Vos tickets Jira, votre documentation Confluence, vos bases de donnees PostgreSQL, vos API metier : autant de contexte critique que l'IA ne peut pas exploiter. Le Model Context Protocol (MCP) change la donne. Ce protocole ouvert permet a Claude Code d'interroger directement vos outils internes, transformant un assistant de code generique en un coequipier qui connait votre stack, vos conventions et vos donnees. Voici comment mettre ca en place concretement.
Pourquoi connecter Claude Code a vos outils internes
Sans MCP, chaque interaction avec Claude Code exige un va-et-vient manuel. Vous copiez un ticket Jira, collez la spec dans le prompt, puis recopiez le schema de votre base de donnees. Ce contexte-switching permanent casse le flow et introduit des erreurs de transcription.
Avec MCP, Claude Code accede directement a ces sources. Il peut lire un ticket, consulter le schema de la base, verifier la documentation interne et generer du code adapte, le tout dans une seule conversation. Les gains mesures sur des equipes de 5 a 15 developpeurs tournent autour de 30 a 45 minutes economisees par developpeur et par jour.
Le protocole est ouvert et standardise. Il fonctionne sur un modele client-serveur ou Claude Code agit comme client MCP et vos outils exposent des serveurs MCP. Chaque serveur declare ses capacites (outils, ressources, prompts) et Claude Code les decouvre automatiquement. Si vous debutez avec le protocole, consultez notre [guide complet du Model Context Protocol](/mcp-model-context-protocol-guide/) pour comprendre l'architecture en profondeur.
Configuration MCP dans Claude Code
Claude Code supporte deux niveaux de configuration MCP : global (pour tous vos projets) et local (par projet). La configuration se fait dans des fichiers JSON.
Configuration globale
Le fichier ~/.claude/settings.json definit les serveurs MCP disponibles partout :
{
"mcpServers": {
"postgres-interne": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://user:pass@db.internal:5432/prod"],
"env": {}
},
"slack": {
"command": "npx",
"args": ["-y", "@anthropic/mcp-server-slack"],
"env": {
"SLACK_BOT_TOKEN": "xoxb-votre-token"
}
}
}
}
Configuration par projet
Pour des serveurs specifiques a un projet, creez un fichier .mcp.json a la racine du depot :
{
"mcpServers": {
"api-interne": {
"command": "node",
"args": ["./mcp-servers/api-interne.js"],
"env": {
"API_BASE_URL": "https://api.internal.company.com",
"API_TOKEN": "${API_TOKEN}"
}
},
"jira": {
"command": "npx",
"args": ["-y", "@anthropic/mcp-server-jira"],
"env": {
"JIRA_URL": "https://company.atlassian.net",
"JIRA_TOKEN": "${JIRA_API_TOKEN}"
}
}
}
}
Les variables d'environnement avec la syntaxe ${VAR} sont resolues depuis votre shell. Cela evite de commiter des tokens dans le depot.
Une fois la configuration en place, lancez Claude Code. Les serveurs MCP demarrent automatiquement et vous pouvez verifier leur statut avec la commande /mcp dans l'interface. Pour une prise en main complete de Claude Code lui-meme, notre [guide Claude Code 2026](/claude-code-guide-complet-2026/) couvre l'installation et les fonctionnalites de base.
Exemples concrets d'integration
Base de donnees PostgreSQL
Le serveur MCP PostgreSQL expose le schema de vos tables et permet d'executer des requetes en lecture. Claude Code peut ainsi generer du code qui respecte exactement votre modele de donnees :
> Claude, genere un endpoint GET /api/users/:id/orders
qui retourne les commandes avec le detail des produits.
Claude Code interroge le serveur MCP PostgreSQL, decouvre les tables users, orders, order_items et products, identifie les cles etrangeres et genere un endpoint avec les jointures correctes. Plus besoin de coller votre schema manuellement.
Jira et Linear
Avec le serveur MCP Jira, Claude Code lit directement les tickets :
> Claude, implemente le ticket BACK-234.
L'IA recupere le titre, la description, les criteres d'acceptation et les commentaires du ticket. Elle genere ensuite le code correspondant, les tests unitaires bases sur les criteres d'acceptation, et peut meme creer la pull request avec une description qui reference le ticket.
Slack
Le serveur MCP Slack permet a Claude Code de consulter des discussions pertinentes. Quand une specification est discutee dans un channel, Claude Code peut rechercher les messages recents pour comprendre les decisions d'architecture prises par l'equipe.
Documentation Confluence
Pour les equipes qui centralisent leur documentation technique sur Confluence, le serveur MCP correspondant donne a Claude Code un acces direct aux pages. Quand vous demandez d'implementer une fonctionnalite, l'IA peut consulter la spec technique, les ADR (Architecture Decision Records) et les conventions de code documentees.
Workflow reel : du ticket a la PR
Voici un workflow complet tel qu'il se deroule dans une equipe qui a configure MCP :
Etape 1 : lecture du ticket. Le developpeur tape dans Claude Code : "Implemente le ticket PROJ-567". Claude Code appelle le serveur MCP Jira et recupere toutes les informations du ticket.
Etape 2 : consultation de la documentation. Le ticket reference une spec technique. Claude Code appelle le serveur MCP Confluence pour lire le document et comprendre les contraintes metier.
Etape 3 : analyse du schema. La feature implique de nouvelles tables. Claude Code interroge le serveur MCP PostgreSQL pour connaitre le schema existant et proposer une migration coherente.
Etape 4 : generation du code. Avec tout ce contexte, Claude Code genere le code de migration, les modeles, les endpoints API, les validations et les tests. Le code respecte les conventions du projet parce que l'IA a lu la documentation interne.
Etape 5 : creation de la PR. Claude Code pousse une branche, cree la pull request sur GitHub avec une description detaillee qui reference le ticket Jira et resume les choix techniques.
Ce workflow qui prenait habituellement une demi-journee se reduit a 45 minutes avec verification humaine incluse. Le developpeur garde le controle total : il relit, ajuste et valide avant de merge.
Creer un serveur MCP custom pour votre API interne
Les serveurs MCP communautaires couvrent les outils courants. Mais votre API metier interne necessite un serveur custom. Voici un exemple simplifie en TypeScript :
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
const server = new McpServer({
name: "api-interne",
version: "1.0.0",
});
// Outil pour recuperer un client par ID
server.tool(
"get-client",
"Recupere les informations d'un client depuis l'API interne",
{ clientId: z.string().describe("Identifiant du client") },
async ({ clientId }) => {
const response = await fetch(
`${process.env.API_BASE_URL}/clients/${clientId}`,
{
headers: { Authorization: `Bearer ${process.env.API_TOKEN}` },
}
);
const client = await response.json();
return {
content: [{ type: "text", text: JSON.stringify(client, null, 2) }],
};
}
);
// Outil pour lister les produits d'un catalogue
server.tool(
"list-products",
"Liste les produits du catalogue interne avec filtres",
{
category: z.string().optional().describe("Categorie de produit"),
limit: z.number().default(20).describe("Nombre max de resultats"),
},
async ({ category, limit }) => {
const params = new URLSearchParams();
if (category) params.set("category", category);
params.set("limit", String(limit));
const response = await fetch(
`${process.env.API_BASE_URL}/products?${params}`,
{
headers: { Authorization: `Bearer ${process.env.API_TOKEN}` },
}
);
const products = await response.json();
return {
content: [{ type: "text", text: JSON.stringify(products, null, 2) }],
};
}
);
async function main() {
const transport = new StdioServerTransport();
await server.connect(transport);
}
main().catch(console.error);
Ce serveur expose deux outils que Claude Code decouvre automatiquement. Pour l'installer, ajoutez-le a votre .mcp.json :
{
"mcpServers": {
"api-interne": {
"command": "npx",
"args": ["tsx", "./mcp-servers/api-interne.ts"],
"env": {
"API_BASE_URL": "${INTERNAL_API_URL}",
"API_TOKEN": "${INTERNAL_API_TOKEN}"
}
}
}
}
Le SDK MCP officiel (@modelcontextprotocol/sdk) fournit tout le necessaire. Vous pouvez exposer des outils (fonctions appelables), des ressources (donnees consultables) et des prompts (templates reutilisables). Comptez une demi-journee pour un serveur basique, une a deux journees pour un serveur complet avec gestion d'erreurs et pagination.
Securite : limiter les permissions et auditer
Connecter Claude Code a vos systemes internes exige une approche rigoureuse de la securite. Voici les principes a appliquer.
Tokens a permissions restreintes
Creez des tokens dedies pour chaque serveur MCP avec le minimum de permissions necessaires :
- PostgreSQL : utilisateur en lecture seule, sans acces aux tables sensibles (credentials, donnees personnelles).
- Jira : token avec acces en lecture aux projets concernes uniquement, pas d'acces admin.
- Slack : bot token avec scope
channels:readetsearch:read, sans capacite de poster. - API interne : token scope limite aux endpoints necessaires, avec rate limiting.
Rotation et stockage des secrets
Ne stockez jamais les tokens dans les fichiers de configuration commits. Utilisez des variables d'environnement ou un gestionnaire de secrets (Vault, AWS Secrets Manager, 1Password CLI). Planifiez une rotation trimestrielle des tokens MCP.
Audit et journalisation
Activez les logs sur vos serveurs MCP pour tracer chaque appel. Enregistrez qui a fait la requete, quel outil a ete appele et quels parametres ont ete passes. Ces logs sont essentiels pour la conformite et le debugging.
Mode confirmation
Claude Code propose un mode ou chaque appel a un outil MCP necessite une validation manuelle. Activez-le pour les serveurs qui accedent a des donnees sensibles ou qui effectuent des actions en ecriture. Vous gardez ainsi un controle humain sur chaque interaction avec vos systemes.
Gains de productivite mesures
Les retours d'equipes qui ont deploye MCP avec Claude Code montrent des resultats significatifs.
Reduction du context-switching. Les developpeurs passent 40 % moins de temps a naviguer entre leurs outils. Le contexte arrive directement dans la conversation avec Claude Code.
Qualite du code genere. Avec acces au schema reel de la base et a la documentation interne, le code genere par Claude Code necessite en moyenne 60 % moins de corrections manuelles qu'un code genere sans ce contexte.
Temps de traitement des tickets. Sur un panel de 50 tickets de complexite moyenne, le temps moyen de traitement passe de 4 heures a 1 heure 30, verification humaine incluse.
Onboarding accelere. Les nouveaux developpeurs beneficient immediatement du contexte interne via MCP. Ils posent leurs questions a Claude Code qui consulte la documentation et la base de code. Le temps d'autonomie passe de 3 semaines a 1 semaine en moyenne.
Ces chiffres varient selon la maturite de la documentation interne et la complexite de la stack. Les gains les plus importants sont observes dans les equipes qui ont une bonne documentation et des API internes bien structurees.
Ce qu'il faut retenir
Le Model Context Protocol transforme Claude Code d'un assistant generique en un outil parfaitement integre a votre ecosysteme technique. La configuration est simple, les serveurs communautaires couvrent les outils courants et la creation d'un serveur custom reste accessible a tout developpeur. Le point cle est la securite : tokens scoped, permissions minimales et audit systematique.
Commencez par connecter un seul outil, celui ou le context-switching vous coute le plus de temps. Mesurez les gains sur deux semaines. Puis etendez progressivement a vos autres systemes internes. L'investissement initial d'une journee de configuration se rentabilise des la premiere semaine d'utilisation.
