API Plugin

Étendez Gemini CLI avec des serveurs MCP, des outils personnalisés et des intégrations puissantes. Connectez-vous aux bases de données, API, systèmes de fichiers et plus encore en utilisant le protocole de contexte de modèle.

Protocole MCPServeurs PersonnalisésIntégration d'Outils

Architecture d'Extension

Gemini CLI utilise le protocole de contexte de modèle (MCP) pour fournir un moyen standardisé de connecter les assistants IA avec des outils externes et des sources de données.

Serveurs MCP

Processus autonomes qui exposent des outils et des ressources via le protocole de contexte de modèle

Intégration d'Outils

Intégrez de manière transparente des outils et services externes dans vos flux de travail IA

Développement Personnalisé

Construisez vos propres serveurs MCP pour étendre Gemini CLI avec des fonctionnalités personnalisées

Types de Serveurs MCP

Explorez différents types de serveurs MCP et leurs capacités

Serveurs de Système de Fichiers

Serveurs qui fournissent l'accès et les opérations du système de fichiers

filesystem

Lire, écrire et gérer les fichiers et répertoires

Capacités:
read_filewrite_filelist_directorycreate_directory

git

Opérations de dépôt Git et contrôle de version

Capacités:
git_statusgit_commitgit_branchgit_log

Serveurs Web et API

Serveurs qui interagissent avec les services web et les API

web-search

Rechercher sur le web et récupérer des informations

Capacités:
web_searchfetch_urlextract_content

github

Intégration API GitHub pour la gestion de dépôts

Capacités:
list_reposcreate_issueget_pull_requests

Serveurs de Base de Données

Serveurs qui fournissent la connectivité et les opérations de base de données

sqlite

Opérations de base de données SQLite

Capacités:
execute_querycreate_tableinsert_data

postgres

Intégration de base de données PostgreSQL

Capacités:
querytransactionschema_info

Exemples de Configuration

Apprenez à configurer les serveurs MCP dans votre configuration Gemini CLI

Configuration de Base

Ajoutez des serveurs MCP à votre fichier .gemini/config.json :

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/files"]
    },
    "git": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-git", "--repository", "/path/to/repo"]
    },
    "web-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-web-search"]
    }
  }
}

Configuration Avancée

Configurez des serveurs personnalisés avec des variables d'environnement et des options avancées :

{
  "mcpServers": {
    "custom-database": {
      "command": "node",
      "args": ["./custom-mcp-server.js"],
      "env": {
        "DATABASE_URL": "postgresql://localhost:5432/mydb",
        "API_KEY": "your-api-key"
      }
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "your-github-token"
      }
    }
  }
}

Configuration de Développement

Configuration pour le développement local et le débogage :

{
  "mcpServers": {
    "local-dev": {
      "command": "node",
      "args": ["./dev-server.js"],
      "cwd": "/path/to/development/server",
      "env": {
        "NODE_ENV": "development",
        "DEBUG": "mcp:*"
      }
    }
  }
}

Développement de Serveur MCP Personnalisé

Construisez votre propre serveur MCP pour étendre Gemini CLI avec des fonctionnalités personnalisées

Exemple Complet de Serveur MCP

Voici un exemple complet d'un serveur MCP personnalisé que vous pouvez utiliser comme point de départ :

#!/usr/bin/env node

import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
} from '@modelcontextprotocol/sdk/types.js';

class CustomMCPServer {
  constructor() {
    this.server = new Server(
      {
        name: 'custom-server',
        version: '0.1.0',
      },
      {
        capabilities: {
          tools: {},
        },
      }
    );

    this.setupToolHandlers();
  }

  setupToolHandlers() {
    // Lister les outils disponibles
    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
      return {
        tools: [
          {
            name: 'custom_tool',
            description: 'Un outil personnalisé qui effectue des opérations spécifiques',
            inputSchema: {
              type: 'object',
              properties: {
                input: {
                  type: 'string',
                  description: 'Entrée pour l'opération personnalisée',
                },
              },
              required: ['input'],
            },
          },
        ],
      };
    });

    // Gérer les appels d'outils
    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
      const { name, arguments: args } = request.params;

      if (name === 'custom_tool') {
        const result = await this.performCustomOperation(args.input);
        return {
          content: [
            {
              type: 'text',
              text: `Résultat de l'opération personnalisée: ${result}`,
            },
          ],
        };
      }

      throw new Error(`Outil inconnu: ${name}`);
    });
  }

  async performCustomOperation(input) {
    // Votre logique personnalisée ici
    return `Traité: ${input}`;
  }

  async run() {
    const transport = new StdioServerTransport();
    await this.server.connect(transport);
    console.error('Serveur MCP personnalisé en cours d'exécution sur stdio');
  }
}

const server = new CustomMCPServer();
server.run().catch(console.error);

Commencer

Étapes rapides pour commencer à utiliser et développer des serveurs MCP

Utiliser des Serveurs Existants

  1. 1Installez un package de serveur MCP : npm install -g @modelcontextprotocol/server-filesystem
  2. 2Ajoutez le serveur à votre .gemini/config.json
  3. 3Redémarrez Gemini CLI pour charger le nouveau serveur
  4. 4Utilisez la commande /mcp pour lister les serveurs disponibles

Développer des Serveurs Personnalisés

  1. 1Installez le SDK MCP : npm install @modelcontextprotocol/sdk
  2. 2Créez votre serveur en utilisant l'exemple ci-dessus
  3. 3Testez votre serveur avec l'inspecteur MCP
  4. 4Configurez-le dans Gemini CLI et commencez à l'utiliser

Ressources Connexes

Explorez davantage le développement de serveurs MCP et de plugins

Documentation du Protocole MCPRéférence API des OutilsDocumentation API Core