Plugin API

Erweitern Sie Gemini CLI mit MCP-Servern, benutzerdefinierten Tools und leistungsstarken Integrationen. Verbinden Sie sich mit Datenbanken, APIs, Dateisystemen und mehr über das Model Context Protocol.

MCP-ProtokollBenutzerdefinierte ServerTool-Integration

Erweiterungsarchitektur

Gemini CLI verwendet das Model Context Protocol (MCP), um eine standardisierte Möglichkeit zu bieten, KI-Assistenten mit externen Tools und Datenquellen zu verbinden.

MCP-Server

Eigenständige Prozesse, die Tools und Ressourcen über das Model Context Protocol bereitstellen

Tool-Integration

Integrieren Sie externe Tools und Services nahtlos in Ihre KI-Workflows

Benutzerdefinierte Entwicklung

Erstellen Sie Ihre eigenen MCP-Server, um Gemini CLI mit benutzerdefinierten Funktionen zu erweitern

MCP-Server-Typen

Erkunden Sie verschiedene Arten von MCP-Servern und ihre Fähigkeiten

Dateisystem-Server

Server, die Dateisystemzugriff und -operationen bereitstellen

filesystem

Dateien und Verzeichnisse lesen, schreiben und verwalten

Fähigkeiten:
read_filewrite_filelist_directorycreate_directory

git

Git-Repository-Operationen und Versionskontrolle

Fähigkeiten:
git_statusgit_commitgit_branchgit_log

Web- und API-Server

Server, die mit Webdiensten und APIs interagieren

web-search

Das Web durchsuchen und Informationen abrufen

Fähigkeiten:
web_searchfetch_urlextract_content

github

GitHub API-Integration für Repository-Management

Fähigkeiten:
list_reposcreate_issueget_pull_requests

Datenbankserver

Server, die Datenbankverbindungen und -operationen bereitstellen

sqlite

SQLite-Datenbankoperationen

Fähigkeiten:
execute_querycreate_tableinsert_data

postgres

PostgreSQL-Datenbankintegration

Fähigkeiten:
querytransactionschema_info

Konfigurationsbeispiele

Erfahren Sie, wie Sie MCP-Server in Ihrer Gemini CLI-Einrichtung konfigurieren

Grundkonfiguration

Fügen Sie MCP-Server zu Ihrer .gemini/config.json-Datei hinzu:

{
  "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"]
    }
  }
}

Erweiterte Konfiguration

Konfigurieren Sie benutzerdefinierte Server mit Umgebungsvariablen und erweiterten Optionen:

{
  "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"
      }
    }
  }
}

Entwicklungskonfiguration

Konfiguration für lokale Entwicklung und Debugging:

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

Benutzerdefinierte MCP-Server-Entwicklung

Erstellen Sie Ihren eigenen MCP-Server, um Gemini CLI mit benutzerdefinierten Funktionen zu erweitern

Vollständiges MCP-Server-Beispiel

Hier ist ein vollständiges Beispiel eines benutzerdefinierten MCP-Servers, den Sie als Ausgangspunkt verwenden können:

#!/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() {
    // Verfügbare Tools auflisten
    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
      return {
        tools: [
          {
            name: 'custom_tool',
            description: 'Ein benutzerdefiniertes Tool, das spezifische Operationen durchführt',
            inputSchema: {
              type: 'object',
              properties: {
                input: {
                  type: 'string',
                  description: 'Eingabe für die benutzerdefinierte Operation',
                },
              },
              required: ['input'],
            },
          },
        ],
      };
    });

    // Tool-Aufrufe behandeln
    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: `Ergebnis der benutzerdefinierten Operation: ${result}`,
            },
          ],
        };
      }

      throw new Error(`Unbekanntes Tool: ${name}`);
    });
  }

  async performCustomOperation(input) {
    // Ihre benutzerdefinierte Logik hier
    return `Verarbeitet: ${input}`;
  }

  async run() {
    const transport = new StdioServerTransport();
    await this.server.connect(transport);
    console.error('Benutzerdefinierter MCP-Server läuft auf stdio');
  }
}

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

Erste Schritte

Schnelle Schritte zum Einstieg in die Nutzung und Entwicklung von MCP-Servern

Vorhandene Server Verwenden

  1. 1Installieren Sie ein MCP-Server-Paket: npm install -g @modelcontextprotocol/server-filesystem
  2. 2Fügen Sie den Server zu Ihrer .gemini/config.json-Datei hinzu
  3. 3Starten Sie Gemini CLI neu, um den neuen Server zu laden
  4. 4Verwenden Sie den Befehl /mcp um verfügbare Server aufzulisten

Benutzerdefinierte Server Entwickeln

  1. 1Installieren Sie das MCP SDK: npm install @modelcontextprotocol/sdk
  2. 2Erstellen Sie Ihren Server mit dem obigen Beispiel
  3. 3Testen Sie Ihren Server mit dem MCP-Inspektor
  4. 4Konfigurieren Sie es in Gemini CLI und beginnen Sie mit der Nutzung

Verwandte Ressourcen

Erfahren Sie mehr über MCP-Server und Plugin-Entwicklung

MCP-Protokoll-DokumentationTools API ReferenzCore API Dokumentation