API Plugin

Extienda Gemini CLI con servidores MCP, herramientas personalizadas e integraciones potentes. Conéctese a bases de datos, APIs, sistemas de archivos y más usando el Protocolo de Contexto de Modelo.

Protocolo MCPServidores PersonalizadosIntegración de Herramientas

Arquitectura de Extensión

Gemini CLI utiliza el Protocolo de Contexto de Modelo (MCP) para proporcionar una forma estandarizada de conectar asistentes de IA con herramientas externas y fuentes de datos.

Servidores MCP

Procesos independientes que exponen herramientas y recursos a través del Protocolo de Contexto de Modelo

Integración de Herramientas

Integre sin problemas herramientas y servicios externos en sus flujos de trabajo de IA

Desarrollo Personalizado

Construya sus propios servidores MCP para extender Gemini CLI con funcionalidad personalizada

Tipos de Servidores MCP

Explore diferentes tipos de servidores MCP y sus capacidades

Servidores de Sistema de Archivos

Servidores que proporcionan acceso y operaciones del sistema de archivos

filesystem

Leer, escribir y gestionar archivos y directorios

Capacidades:
read_filewrite_filelist_directorycreate_directory

git

Operaciones de repositorio Git y control de versiones

Capacidades:
git_statusgit_commitgit_branchgit_log

Servidores Web y API

Servidores que interactúan con servicios web y APIs

web-search

Buscar en la web y recuperar información

Capacidades:
web_searchfetch_urlextract_content

github

Integración de API de GitHub para gestión de repositorios

Capacidades:
list_reposcreate_issueget_pull_requests

Servidores de Base de Datos

Servidores que proporcionan conectividad y operaciones de base de datos

sqlite

Operaciones de base de datos SQLite

Capacidades:
execute_querycreate_tableinsert_data

postgres

Integración de base de datos PostgreSQL

Capacidades:
querytransactionschema_info

Ejemplos de Configuración

Aprenda a configurar servidores MCP en su configuración de Gemini CLI

Configuración Básica

Agregue servidores MCP a su archivo .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"]
    }
  }
}

Configuración Avanzada

Configure servidores personalizados con variables de entorno y opciones avanzadas:

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

Configuración de Desarrollo

Configuración para desarrollo local y depuración:

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

Desarrollo de Servidor MCP Personalizado

Construya su propio servidor MCP para extender Gemini CLI con funcionalidad personalizada

Ejemplo Completo de Servidor MCP

Aquí hay un ejemplo completo de un servidor MCP personalizado que puede usar como punto de partida:

#!/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() {
    // Listar herramientas disponibles
    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
      return {
        tools: [
          {
            name: 'custom_tool',
            description: 'Una herramienta personalizada que realiza operaciones específicas',
            inputSchema: {
              type: 'object',
              properties: {
                input: {
                  type: 'string',
                  description: 'Entrada para la operación personalizada',
                },
              },
              required: ['input'],
            },
          },
        ],
      };
    });

    // Manejar llamadas de herramientas
    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: `Resultado de operación personalizada: ${result}`,
            },
          ],
        };
      }

      throw new Error(`Herramienta desconocida: ${name}`);
    });
  }

  async performCustomOperation(input) {
    // Su lógica personalizada aquí
    return `Procesado: ${input}`;
  }

  async run() {
    const transport = new StdioServerTransport();
    await this.server.connect(transport);
    console.error('Servidor MCP personalizado ejecutándose en stdio');
  }
}

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

Comenzar

Pasos rápidos para comenzar a usar y desarrollar servidores MCP

Usar Servidores Existentes

  1. 1Instale un paquete de servidor MCP: npm install -g @modelcontextprotocol/server-filesystem
  2. 2Agregue el servidor a su .gemini/config.json
  3. 3Reinicie Gemini CLI para cargar el nuevo servidor
  4. 4Use el comando /mcp para listar servidores disponibles

Desarrollar Servidores Personalizados

  1. 1Instale el SDK MCP: npm install @modelcontextprotocol/sdk
  2. 2Cree su servidor usando el ejemplo anterior
  3. 3Pruebe su servidor con el inspector MCP
  4. 4Configúrelo en Gemini CLI y comience a usarlo

Recursos Relacionados

Explore más sobre el desarrollo de servidores MCP y plugins

Documentación del Protocolo MCPReferencia API de HerramientasDocumentación API Core