Explication détaillée des fonctionnalités de DBAPI MCP : transformez vos API de données en outils pour les agents intelligents d’IA

Qu’est-ce que le MCP ?

Le MCP (Model Context Protocol, protocole de contexte du modèle) est un protocole standard ouvert proposé et open source par Anthropic. Il définit la manière dont les modèles d’IA interagissent avec les outils externes et les sources de données, s’apparentant à une « interface USB‑C du monde de l’IA » : grâce à une spécification protocolaire unifiée, toute service implémentant le MCP peut être intégré de manière transparente aux différents clients et frameworks d’IA.

La version entreprise 4.5.0 de DBAPI intègre officiellement la capacité MCP Server ; vous pouvez ainsi mapper en un clic les API déjà publiées dans DBAPI en tant qu’outils MCP, rendus disponibles pour la découverte et l’appel par les clients IA.

Quels problèmes le MCP résout‑il ?

Dans les applications de données d’entreprise, l’IA doit accéder aux bases de données, interroger les données métier et appeler des services internes. Les approches traditionnelles exigent le développement séparé d’interfaces et de codes d’intégration pour chaque scénario, ce qui est peu efficace et coûteux à maintenir.

Les fonctionnalités MCP de DBAPI permettent :

• Intégration sans code : aucune ligne de code d’intégration IA n’est requise ; les API existantes de DBAPI deviennent automatiquement des outils appelables par l’IA.
• Gestion unifiée : tous les outils de données sont gérés de manière centralisée dans l’interface d’administration de DBAPI, avec des autorisations, des limites de débit et des métriques de surveillance prêtes à l’emploi.
• Écosystème ouvert : prise en charge des principaux clients et frameworks d’IA tels que Claude Desktop, Cursor, LangChain, Spring AI, etc.
• Sécurité d’entreprise : les API privées sont protégées par une authentification basée sur des jetons, avec des droits d’accès finement contrôlés.

Principe de fonctionnement

Client IA / Framework IA (Claude Desktop / Cursor / LangChain / Spring AI)
        │ Protocole MCP (HTTP streamable)
        ▼
  Serveur MCP de DBApi (port 8526)
        │ Appels HTTP
        ▼
  Backend de DBApi (port 8520 / Gateway)
        │
        ▼
      Base de données / Elasticsearch / Interfaces tierces

Le serveur MCP agit comme un pont, enregistrant les API publiées par le backend de DBAPI en tant qu’outils MCP. Le client IA découvre la liste des outils via le protocole MCP standard et lance ses requêtes ; le serveur MCP transmet ces requêtes au backend de DBAPI pour exécution, puis renvoie le résultat à l’IA.

Démarrage rapide

Prérequis

• DBAPI version entreprise 4.5.0 ou supérieure
• Le backend de DBAPI est démarré (adresse par défaut : http://127.0.0.1:8520)
• Au moins une API a été créée et mise en ligne

Démarrer le serveur MCP

# 1. Éditer le fichier de configuration
vim mcp/mcp-config.yaml

# 2. Lancer le service MCP
bash bin/dbapi-mcp.sh start

Publier une API sur le MCP

Seules les API déjà en ligne et dont l’option MCP activée seront exposées en tant qu’outils MCP.

1. Connectez-vous à l’interface d’administration de DBAPI.
2. Accédez à la page de gestion des API.
3. Sélectionnez l’API souhaitée et activez l’option MCP dans la barre d’actions.
4. Une fois activée, le serveur MCP synchronisera automatiquement cette API lors du prochain cycle de rafraîchissement.

Appeler un outil MCP

Adresse du point d’accès MCP : http://<MCP_SERVER_HOST>:8526/mcp

Obtenir la liste des outils :

curl http://localhost:8526/mcp \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

Appeler un outil :

curl http://localhost:8526/mcp \
  -H "Content-Type: application/json" \
  -H "Authorization: YOUR_BUSINESS_TOKEN" \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"dbapi_xxxx","arguments":{"key":"value"}}}'

Intégration avec les clients IA

Le serveur MCP de DBAPI utilise le protocole HTTP streamable. La plupart des clients (Claude Desktop, Codex CLI, Cursor, LangChain, Spring AI) utilisent automatiquement l’HTTP streamable en fonction de l’URL ; OpenClaw nécessite quant à lui d’indiquer explicitement transport: "streamable-http".

Claude Desktop

Éditez le fichier de configuration (~/Library/Application Support/Claude/claude_desktop_config.json ou %APPDATA%\Claude\claude_desktop_config.json) :

{
  "mcpServers": {
    "dbapi": {
      "url": "http://localhost:8526/mcp"
    }
  }
}

Codex CLI

Le CLI de Codex d’OpenAI prend en charge le transport HTTP streamable via le protocole MCP. Ajoutez l’outil via la commande suivante :

codex mcp add dbapi --url http://localhost:8526/mcp

Ou éditez directement le fichier ~/.codex/config.toml :

[mcp_servers.dbapi]
transport = { type = "streamable_http", url = "http://localhost:8526/mcp" }
enabled = true

Pour les API privées nécessitant un jeton, utilisez env_http_headers pour lire le jeton depuis les variables d’environnement :

export DBAPI_TOKEN=your_token_here
codex mcp add dbapi --url http://localhost:8526/mcp

[mcp_servers.dbapi]
transport = { type = "streamable_http", url = "http://localhost:8526/mcp" }
env_http_headers = { "Authorization" = "DBAPI_TOKEN" }
enabled = true

OpenClaw

OpenClaw, en tant que plateforme d’agents IA, supporte la connexion au serveur MCP. Configurez‑le via la commande openclaw mcp set :

openclaw mcp set dbapi '{"url":"http://localhost:8526/mcp","transport":"streamable-http"}'

Ou ajoutez la configuration dans le fichier de paramètres :

{
  "mcp": {
    "servers": {
      "dbapi": {
        "url": "http://localhost:8526/mcp",
        "transport": "streamable-http"
      }
    }
  }
}

Pour les API privées nécessitant un jeton, ajoutez le champ headers :

openclaw mcp set dbapi '{"url":"http://localhost:8526/mcp","transport":"streamable-http","headers":{"Authorization":"YOUR_TOKEN"}}'

Cursor

Éditez le fichier .cursor/mcp.json :

{
  "mcpServers": {
    "dbapi": {
      "url": "http://localhost:8526/mcp",
      "headers": {
        "Authorization": "YOUR_BUSINESS_TOKEN"
      }
    }
  }
}

LangChain

LangChain offre une prise en charge native du client MCP ; il suffit d’utiliser MCPAdapt pour établir la connexion :

from langchain_mcp_adapters.client import MCPClient

async with MCPClient("http://localhost:8526/mcp") as client:
    tools = await client.list_tools()
    result = await client.call_tool("dbapi_xxxx", {"key": "value"})

Spring AI

Spring AI prend en charge le MCP via le module mcp-client-webmvc :

McpClient client = McpClient.sync(new HttpMcpTransport("http://localhost:8526/mcp"));
List<Tool> tools = client.listTools();
client.callTool("dbapi_xxxx", Map.of("key", "value"));

Mécanisme d’authentification

Type d’API	Description	Jeton requis ?
API publique	Accessible à tous	Non
API privée	Accessible uniquement aux clients autorisés	Oui, via l’en-tête Authorization

Obtention du jeton

# Obtenir le clientId et le secret (créés dans l’administration des clients)
curl "http://localhost:8520/token/generate?clientId=YOUR_CLIENT_ID&secret=YOUR_CLIENT_SECRET"

Le jeton obtenu doit être inséré dans l’en‑tête Authorization du client MCP.

Les jetons ont une durée de validité ; après expiration, ils doivent être renouvelés. Vous pouvez définir une période de validité plus longue dans l’administration des clients afin d’éviter des mises à jour fréquentes.

Scénarios d’application en entreprise

Scénario 1 : Assistant de consultation numérique

Après avoir publié une API d’interrogation de base de données en tant qu’outil MCP, les collaborateurs peuvent poser leurs questions en langage naturel directement depuis Claude Desktop :

« Quels sont les 10 produits ayant réalisé les meilleures ventes dans la région de l’Est le mois dernier ? »

L’IA appelle automatiquement l’API de requête correspondante de DBAPI, renvoie le résultat et le présente sous forme de réponse en langage naturel. Plus besoin d’apprendre SQL ni de se connecter aux systèmes métiers.

Scénario 2 : Génération intelligente de rapports

En orchestrant plusieurs APIs d’interrogation de données pour former une interface complète de génération de rapports, puis en publiant celle‑ci en tant qu’outil MCP, les clients IA peuvent générer automatiquement des analyses structurées.

Scénario 3 : Agent de surveillance des anomalies de données

Enregistrez les APIs de suivi des données comme outils pour l’agent LangChain. Cet agent effectue des inspections programmées des données métier et envoie des alertes via des bots DingTalk ou Feishu dès la détection d’anomalies.

Scénario 4 : Renforcement de la base de connaissances d’entreprise

Publiez les interfaces d’interrogation des systèmes internes (consultation des commandes, informations clients, état des stocks, etc.) en tant qu’outils MCP, puis intégrez‑les à l’assistant IA maison de l’entreprise, dotant ainsi l’IA de la capacité d’interroger en temps réel les données de l’entreprise.

Points d’attention

• Le serveur MCP écoute par défaut sur le port 8526 ; cette valeur peut être modifiée dans le fichier mcp-config.yaml.
• Seules les API déjà en ligne et dont l’option MCP activée sont exposées.
• Après toute modification d’une API, le serveur MCP synchronise automatiquement les métadonnées telles que l’URL et les définitions des paramètres, sans nécessiter de redémarrage.
• DBAPI dispose déjà d’un système complet d’authentification des API (authentification par jeton, autorisation des clients) ainsi que de règles de pare‑feu IP ; les clients MCP héritent directement de ces mesures de sécurité, sans besoin de configuration supplémentaire.
• Si vous utilisez des API privées, assurez‑vous que le client a bien reçu l’autorisation correspondante.

Version requise : DBAPI version entreprise 4.5.0 ou supérieure prend en charge les fonctionnalités MCP.