Gemini MCP Server

Un servidor MCP para Google Gemini AI con Inteligencia de Herramientas Inteligente y preferencias autónomas y configurables.

Documentación

Servidor Gemini MCP con Inteligencia de Herramientas Inteligentes

Bienvenido al Servidor Gemini MCP, el primer servidor MCP con Inteligencia de Herramientas Inteligentes - un sistema revolucionario de autoaprendizaje que se adapta a tus preferencias y mejora con el tiempo. Esta plataforma integral proporciona 7 herramientas impulsadas por IA con mejora automática de indicaciones y conciencia contextual.

🚀 Descripción General de Funciones

🤖 7 Herramientas Impulsadas por IA

  • Generación de Imágenes - Crea imágenes a partir de indicaciones de texto usando Gemini 2.0 Flash
  • Edición de Imágenes - Edita imágenes existentes con instrucciones en lenguaje natural
  • Chat - Conversaciones interactivas con respuestas conscientes del contexto
  • Transcripción de Audio - Convierte audio a texto con modo verbatim opcional
  • Ejecución de Código - Ejecuta código Python en un entorno sandbox seguro
  • Análisis de Video - Analiza contenido de video para resúmenes, transcripciones y perspectivas
  • Análisis de Imágenes - Extrae objetos, texto y descripciones detalladas de imágenes

🧠 Sistema de Inteligencia de Herramientas Inteligentes (Primero en el Ecosistema MCP)

  • Autoaprendizaje - Aprende automáticamente de interacciones exitosas
  • Detección de Contexto - Reconoce investigación de conciencia, codificación, depuración y otros contextos
  • Reconocimiento de Patrones - Identifica patrones de uso y preferencias del usuario
  • Mejora de Indicaciones - Refina indicaciones para un mejor rendimiento del modelo de IA
  • Memoria Persistente - Almacena preferencias aprendidas entre sesiones
  • Migración Automática - Mejora sin problemas el almacenamiento de preferencias

📦 Inicio Rápido

Instalación

git clone https://github.com/Garblesnarff/gemini-mcp-server.git
cd gemini-mcp-server
npm install

Configuración

  1. Obtén tu clave API de Gemini en Google AI Studio
  2. Copia la plantilla de entorno:
    cp .env.example .env
    
  3. Edita .env y agrega tu clave API:
    GEMINI_API_KEY=your_actual_api_key_here
    OUTPUT_DIR=/path/to/your/output/directory  # Optional
    DEBUG=false  # Optional
    

Ejecutando el Servidor

npm start
# or for development with debug logging:
npm run dev

Integración con Claude Desktop

Agrega a tu configuración de Claude Desktop (claude_desktop_config.json):

{
  \"mcpServers\": {
    \"gemini\": {
      \"command\": \"node\",
      \"args\": [\"/path/to/gemini-mcp-server/gemini-server.js\"],
      \"env\": {
        \"GEMINI_API_KEY\": \"your_api_key_here\"
      }
    }
  }
}

🛠️ Referencia de Herramientas

1. Generación de Imágenes (generate_image)

Genera imágenes a partir de descripciones de texto usando Gemini 2.0 Flash.

Parámetros:

  • prompt (cadena, requerido) - Descripción de la imagen a generar
  • context (cadena, opcional) - Contexto para la mejora de Inteligencia de Herramientas Inteligentes

Ejemplo:

{
  \"prompt\": \"A serene mountain landscape at sunset with vibrant colors\",
  \"context\": \"artistic\"
}

Devuelve:

{
  \"content\": [{
    \"type\": \"text\",
    \"text\": \"Generated a beautiful mountain landscape image.\"
  }, {
    \"type\": \"image\", 
    \"data\": \"base64_image_data\",
    \"mimeType\": \"image/png\"
  }]
}

2. Edición de Imágenes (gemini-edit-image)

Edita imágenes existentes usando instrucciones en lenguaje natural.

Parámetros:

  • image_path (cadena, requerido) - Ruta al archivo de imagen a editar
  • edit_instruction (cadena, requerido) - Descripción de los cambios deseados
  • context (cadena, opcional) - Contexto para la mejora

Ejemplo:

{
  \"image_path\": \"/path/to/image.jpg\",
  \"edit_instruction\": \"Add shooting stars to the night sky\",
  \"context\": \"artistic\"
}

3. Chat (gemini-chat)

Conversaciones interactivas con Gemini AI que aprende tus preferencias.

Parámetros:

  • message (cadena, requerido) - Tu mensaje o pregunta
  • context (cadena, opcional) - Contexto para la Inteligencia de Herramientas Inteligentes

Ejemplo:

{
  \"message\": \"Explain quantum computing in simple terms\",
  \"context\": \"consciousness\"  // Will apply academic rigor enhancement
}

4. Transcripción de Audio (gemini-transcribe-audio)

Convierte archivos de audio a texto con mejora de Inteligencia de Herramientas Inteligentes.

Parámetros:

  • file_path (cadena, requerido) - Ruta al archivo de audio (MP3, WAV, FLAC, AAC, OGG, WEBM, M4A)
  • language (cadena, opcional) - Indicación de idioma para mayor precisión
  • context (cadena, opcional) - Usa "verbatim" para transcripción palabra por palabra exacta
  • preserve_spelled_acronyms (booleano, opcional) - Mantén U-R-L en lugar de URL

Ejemplo (Estándar):

{
  \"file_path\": \"/path/to/audio.mp3\",
  \"language\": \"en\"
}

Ejemplo (Modo Verbatim):

{
  \"file_path\": \"/path/to/audio.mp3\",
  \"context\": \"verbatim\",  // Gets exact word-for-word transcription
  \"preserve_spelled_acronyms\": true
}

Características del Modo Verbatim:

  • Captura todos los "um", "eh", "como", palabras repetidas
  • Preserva expresiones emocionales: [risas], [suspiros], [se aclara la garganta]
  • Mantiene la puntuación y estructura de oraciones originales
  • Sin resumen ni limpieza

5. Ejecución de Código (gemini-code-execute)

Ejecuta código Python en un entorno sandbox seguro.

Parámetros:

  • code (cadena, requerido) - Código Python a ejecutar
  • context (cadena, opcional) - Contexto para la mejora

Ejemplo:

{
  \"code\": \"import pandas as pd\\ndata = {'x': [1,2,3], 'y': [4,5,6]}\\ndf = pd.DataFrame(data)\\nprint(df.describe())\",
  \"context\": \"code\"
}

6. Análisis de Video (gemini-analyze-video)

Analiza contenido de video para resúmenes, transcripciones y perspectivas detalladas.

Parámetros:

  • file_path (cadena, requerido) - Ruta al archivo de video (MP4, MOV, AVI, WEBM, MKV, FLV)
  • analysis_type (cadena, opcional) - "summary", "transcript", "objects", "detailed", "custom"
  • context (cadena, opcional) - Contexto para la mejora

Ejemplo:

{
  \"file_path\": \"/path/to/video.mp4\",
  \"analysis_type\": \"detailed\"
}

7. Análisis de Imágenes (gemini-analyze-image)

Extrae información detallada de imágenes incluyendo objetos, texto y descripciones.

Parámetros:

  • file_path (cadena, requerido) - Ruta al archivo de imagen (JPEG, PNG, WebP, HEIC, HEIF, BMP, GIF)
  • analysis_type (cadena, opcional) - "summary", "objects", "text", "detailed", "custom"
  • context (cadena, opcional) - Contexto para la mejora

Ejemplo:

{
  \"file_path\": \"/path/to/image.jpg\",
  \"analysis_type\": \"objects\"
}

🧠 Sistema de Inteligencia de Herramientas Inteligentes

Cómo Funciona

El sistema de Inteligencia de Herramientas Inteligentes es el primero de su tipo en el ecosistema MCP. Automáticamente:

  1. Detecta Contexto - Reconoce si estás haciendo investigación de conciencia, codificación, depuración, etc.
  2. Mejora Indicaciones - Agrega instrucciones relevantes basadas en patrones aprendidos
  3. Aprende Patrones - Almacena patrones de interacción exitosos para uso futuro
  4. Se Adapta con el Tiempo - Mejora al ayudarte con cada interacción

Tipos de Contexto

El sistema reconoce estos contextos y aplica mejoras apropiadas:

  • consciousness - Agrega rigor académico, citas, explicaciones detalladas
  • code - Incluye ejemplos prácticos, código funcional, mejores prácticas
  • debugging - Se enfoca en análisis de causa raíz y correcciones específicas
  • general - Aplica respuestas integrales y estructuradas
  • verbatim - Para transcripción de audio, proporciona salida palabra por palabra exacta

Ubicación de Almacenamiento

Las preferencias se almacenan internamente en ./data/tool-preferences.json con migración automática desde almacenamiento externo.

Implementando Inteligencia de Herramientas Inteligentes en Tu Servidor MCP

¿Quieres agregar esta capacidad revolucionaria a tu propio servidor MCP? Así es cómo:

1. Arquitectura Central

// src/intelligence/context-detector.js
class ContextDetector {
  detectContext(prompt, toolName) {
    // Implement pattern matching for different contexts
    if (this.isConsciousnessContext(prompt)) return 'consciousness';
    if (this.isCodeContext(prompt)) return 'code';
    if (this.isDebuggingContext(prompt)) return 'debugging';
    return 'general';
  }
}

// src/intelligence/prompt-enhancer.js  
class PromptEnhancer {
  enhancePrompt(originalPrompt, context, toolName) {
    // Apply context-specific enhancements
    const enhancement = this.getEnhancementForContext(context);
    return `${originalPrompt}\\n\\n${enhancement}`;
  }
}

// src/intelligence/preference-store.js
class PreferencesManager {
  async storePattern(original, enhanced, context, toolName, success) {
    // Store successful patterns for future learning
  }
  
  async getPatterns(context) {
    // Retrieve learned patterns for context
  }
}

2. Patrón de Integración

// In your tool's execute method:
async execute(args) {
  const intelligence = IntelligenceSystem.getInstance();
  
  // Detect context and enhance prompt
  const context = args.context || intelligence.contextDetector.detectContext(args.prompt, this.name);
  const enhancedPrompt = await intelligence.enhancePrompt(args.prompt, context, this.name);
  
  // Execute with enhanced prompt
  const result = await this.geminiService.generateContent(enhancedPrompt);
  
  // Store successful pattern
  await intelligence.storeSuccessfulPattern(args.prompt, enhancedPrompt, context, this.name);
  
  return result;
}

3. Archivos Clave de Implementación

Estudia estos archivos de este repositorio:

  • src/intelligence/index.js - Coordinador principal de inteligencia
  • src/intelligence/context-detector.js - Lógica de reconocimiento de contexto
  • src/intelligence/prompt-enhancer.js - Aplicación de mejoras
  • src/intelligence/preference-store.js - Almacenamiento y recuperación de patrones
  • src/tools/base-tool.js - Integración con la ejecución de herramientas

🧪 Pruebas

Ejecutar Suite de Pruebas

# Test basic functionality
npm test

# Test Smart Tool Intelligence
node test-tool-intelligence-full.js

# Test internal storage
node test-internal-storage.js

# Test verbatim transcription
node test-verbatim-mode.js

Ejemplos de Pruebas Manuales

# Test image generation
echo '{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"tools/call\",\"params\":{\"name\":\"generate_image\",\"arguments\":{\"prompt\":\"A cute robot reading a book\"}}}' | node gemini-server.js

# Test chat with consciousness context
echo '{\"jsonrpc\":\"2.0\",\"id\":2,\"method\":\"tools/call\",\"params\":{\"name\":\"gemini-chat\",\"arguments\":{\"message\":\"What is consciousness?\",\"context\":\"consciousness\"}}}' | node gemini-server.js

📊 Rendimiento y Límites

Límites de Tamaño de Archivo

  • Imágenes: 20MB (JPEG, PNG, WebP, HEIC, HEIF, BMP, GIF)
  • Audio: 20MB (MP3, WAV, FLAC, AAC, OGG, WEBM, M4A)
  • Video: 100MB (MP4, MOV, AVI, WEBM, MKV, FLV)

Límites de Velocidad de API

  • Sigue los límites de velocidad de la API de Google Gemini
  • Manejo de errores y lógica de reintentos integrados
  • Degradación elegante cuando se excede la cuota

🏗️ Análisis Profundo de Arquitectura

Diseño Modular

src/
├── server.js              # MCP protocol handler
├── config.js              # Configuration management
├── tools/                 # Tool implementations
│   ├── index.js           # Tool registry & dispatcher
│   ├── base-tool.js       # Abstract base class
│   ├── chat.js            # Chat tool
│   ├── image-generation.js # Image generation tool
│   ├── image-editing.js   # Image editing tool
│   ├── audio-transcription.js # Audio transcription tool
│   ├── code-execution.js  # Code execution tool
│   ├── video-analysis.js  # Video analysis tool
│   └── image-analysis.js  # Image analysis tool
├── intelligence/          # Smart Tool Intelligence
│   ├── index.js           # Intelligence coordinator
│   ├── context-detector.js # Context recognition
│   ├── prompt-enhancer.js # Prompt enhancement
│   └── preference-store.js # Pattern storage
├── gemini/               # Gemini API integration
│   ├── gemini-service.js # API service layer
│   └── request-handler.js # Request formatting
└── utils/                # Utilities
    ├── logger.js         # Logging system
    └── file-utils.js     # File operations

Flujo del Sistema de Inteligencia

  1. Solicitud Recibida → Se llama al método de ejecución de la herramienta
  2. Detección de Contexto → Analizar la indicación en busca de pistas de contexto
  3. Recuperación de Patrones → Obtener patrones aprendidos relevantes
  4. Mejora de Indicaciones → Aplicar mejoras específicas del contexto
  5. Ejecución de API → Enviar indicación mejorada a Gemini
  6. Almacenamiento de Patrones → Almacenar patrón de interacción exitoso
  7. Devolución de Respuesta → Devolver resultado mejorado al usuario

🔧 Personalización

Agregando Nuevos Contextos

// In src/intelligence/context-detector.js
isMyCustomContext(prompt) {
  const patterns = [
    /custom pattern 1/i,
    /custom pattern 2/i
  ];
  return patterns.some(pattern => pattern.test(prompt));
}

// In src/intelligence/prompt-enhancer.js
getEnhancementForContext(context) {
  const enhancements = {
    'my_custom_context': 'Apply my custom enhancement instructions here.',
    // ... other contexts
  };
  return enhancements[context] || enhancements.general;
}

Agregando Nuevas Herramientas

  1. Crea el archivo de herramienta en src/tools/my-new-tool.js
  2. Extiende la clase BaseTool
  3. Implementa el método execute con integración de inteligencia
  4. Registra en src/tools/index.js
// src/tools/my-new-tool.js
class MyNewTool extends BaseTool {
  constructor(geminiService, intelligenceSystem) {
    super('my-new-tool', 'Description of my tool', geminiService, intelligenceSystem);
  }
  
  async execute(args) {
    // Use intelligence system for enhancement
    const context = args.context || this.detectContext(args.input);
    const enhancedPrompt = await this.enhancePrompt(args.input, context);
    
    // Your tool logic here
    const result = await this.geminiService.someMethod(enhancedPrompt);
    
    // Store successful pattern  
    await this.storeSuccessfulPattern(args.input, enhancedPrompt, context);
    
    return result;
  }
}

🐛 Solución de Problemas

Problemas Comunes

Error "Falta GEMINI_API_KEY"

# Ensure .env file exists and contains your API key
cp .env.example .env
# Edit .env and add: GEMINI_API_KEY=your_key_here

Errores de "Archivo no encontrado"

# Ensure file paths are absolute and files exist
# Check file permissions and formats

El Sistema de Inteligencia No Aprende

# Check data directory permissions
ls -la data/
# Verify tool-preferences.json is writable

Modo de Depuración

DEBUG=true npm start
# or
npm run dev

Ubicación de Registros

  • Registros de aplicación: Salida de consola
  • Patrones de inteligencia: ./data/tool-preferences.json
  • Imágenes generadas: $OUTPUT_DIR (predeterminado: ~/Claude/gemini-images)

🤝 Contribuciones

¡Damos la bienvenida a contribuciones! Este proyecto representa un nuevo paradigma en el desarrollo de servidores MCP.

Configuración de Desarrollo

git clone https://github.com/Garblesnarff/gemini-mcp-server.git
cd gemini-mcp-server
npm install
npm run dev

Áreas para Contribuir

  • Nuevos Contextos - Agregar soporte para dominios especializados
  • Patrones Mejorados - Mejorar algoritmos de aprendizaje
  • Nuevas Herramientas - Expandir las capacidades de Gemini AI
  • Rendimiento - Optimizar el rendimiento del sistema de inteligencia
  • Documentación - Mejorar guías y ejemplos

📈 Hoja de Ruta

  • Soporte Multilingüe - Detección de contexto en múltiples idiomas
  • Analítica Avanzada - Patrones de uso y métricas de rendimiento
  • Encadenamiento de Herramientas - Coordinación inteligente entre múltiples herramientas
  • Modelos Personalizados - Soporte para modelos Gemini ajustados
  • Aprendizaje Colaborativo - Compartir patrones anonimizados entre instancias
  • Interfaz Visual - Configuración y monitoreo basados en web

🌟 Por Qué Esto Importa

Este es el primer servidor MCP que realmente aprende y se adapta. Los servidores MCP tradicionales son estáticos - hacen lo mismo cada vez. Nuestro sistema de Inteligencia de Herramientas Inteligentes representa un cambio de paradigma hacia herramientas de IA que se vuelven más útiles con el tiempo.

Para Usuarios: Mejores resultados con menos esfuerzo a medida que el sistema aprende tus preferencias. Para Desarrolladores: Un modelo para construir herramientas de IA verdaderamente inteligentes y adaptativas. Para el Ecosistema MCP: Un nuevo estándar para lo que los servidores MCP pueden llegar a ser.

📄 Licencia

Este proyecto está licenciado bajo la Licencia MIT - siéntete libre de usar, modificar y distribuir.

🙏 Agradecimientos

Construido con:

  • Google Gemini AI - Impulsando las capacidades centrales de IA
  • Model Context Protocol - Habilitando integración sin problemas
  • Node.js y NPM - Tiempo de ejecución y gestión de paquetes
  • Claude y Rob - Colaboración humano-IA en su máxima expresión

¿Listo para experimentar el futuro de los servidores MCP? Comienza ahora y observa cómo tus herramientas de IA se vuelven más inteligentes con cada interacción. 🚀