@rlabs-inc/gemini-mcp 0.5.0

package/dist/gemini-client.js

@@ -0,0 +1,399 @@
+/**
+ * Gemini Client - Provides access to Google's Generative AI models
+ *
+ * This module initializes and manages the connection to Google's Gemini API.
+ * Supports Gemini 3 Pro, Flash, image generation (Nano Banana Pro), and video generation (Veo).
+ *
+ * Key Gemini 3 Features:
+ * - Thinking Levels: Control reasoning depth (minimal, low, medium, high)
+ * - 4K Image Generation: Up to 4K resolution with Google Search grounding
+ * - Multi-turn Image Editing: Conversational image refinement
+ */
+import { GoogleGenAI, Modality } from '@google/genai';
+import { logger } from './utils/logger.js';
+import * as fs from 'fs';
+import * as path from 'path';
+// Global clients
+let genAI;
+let proModelName;
+let flashModelName;
+let imageModelName;
+let videoModelName;
+// Output directory for generated files
+let outputDir;
+/**
+ * Initialize the Gemini client with configured models
+ */
+export async function initGeminiClient() {
+    const apiKey = process.env.GEMINI_API_KEY;
+    if (!apiKey) {
+        throw new Error('GEMINI_API_KEY environment variable is required');
+    }
+    try {
+        // Initialize the API client
+        genAI = new GoogleGenAI({ apiKey });
+        // Set up models - Gemini 3 defaults (latest preview)
+        proModelName = process.env.GEMINI_PRO_MODEL || 'gemini-3-pro-preview';
+        flashModelName = process.env.GEMINI_FLASH_MODEL || 'gemini-3-flash-preview';
+        imageModelName = process.env.GEMINI_IMAGE_MODEL || 'gemini-3-pro-image-preview';
+        videoModelName = process.env.GEMINI_VIDEO_MODEL || 'veo-2.0-generate-001';
+        // Set up output directory for generated files
+        outputDir = process.env.GEMINI_OUTPUT_DIR || path.join(process.cwd(), 'gemini-output');
+        if (!fs.existsSync(outputDir)) {
+            fs.mkdirSync(outputDir, { recursive: true });
+            logger.info(`Created output directory: ${outputDir}`);
+        }
+        // Use the user's preferred model for init test, fallback to flash (higher free tier limits)
+        // This fixes issue #7 - init test was always using pro model causing 429 errors on free tier
+        const initModel = process.env.GEMINI_MODEL || flashModelName;
+        // Test connection with timeout and retry
+        let connected = false;
+        let attempts = 0;
+        const maxAttempts = 3;
+        while (!connected && attempts < maxAttempts) {
+            try {
+                attempts++;
+                logger.info(`Connecting to Gemini API (attempt ${attempts}/${maxAttempts}) using ${initModel}...`);
+                // Set up a timeout for the connection test
+                const timeoutPromise = new Promise((_, reject) => {
+                    setTimeout(() => reject(new Error('Connection timeout')), 10000);
+                });
+                // Test connection with user's preferred model or flash (better free tier limits)
+                const connectionPromise = genAI.models.generateContent({
+                    model: initModel,
+                    contents: 'Test connection',
+                });
+                const result = await Promise.race([connectionPromise, timeoutPromise]);
+                if (!result) {
+                    throw new Error('Failed to connect to Gemini API: empty response');
+                }
+                connected = true;
+                logger.info(`Successfully connected to Gemini API`);
+                logger.info(`Pro model: ${proModelName}`);
+                logger.info(`Flash model: ${flashModelName}`);
+                logger.info(`Image model: ${imageModelName}`);
+                logger.info(`Video model: ${videoModelName}`);
+                logger.info(`Output directory: ${outputDir}`);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                logger.warn(`Connection attempt ${attempts} failed: ${errorMessage}`);
+                if (attempts >= maxAttempts) {
+                    throw new Error(`Failed to connect to Gemini API after ${maxAttempts} attempts: ${errorMessage}`);
+                }
+                // Wait before retry
+                await new Promise((resolve) => setTimeout(resolve, 2000));
+            }
+        }
+    }
+    catch (error) {
+        logger.error('Failed to initialize Gemini client:', error);
+        throw error;
+    }
+}
+/**
+ * Generate content using the Gemini Pro model
+ *
+ * @param prompt - The prompt to send to Gemini
+ * @param options - Generation options including thinking level
+ * @returns The generated text response
+ *
+ * Gemini 3 Pro supports thinking levels: low, high (default)
+ */
+export async function generateWithGeminiPro(prompt, options = {}) {
+    try {
+        logger.prompt(prompt);
+        const { thinkingLevel } = options;
+        // Build config with optional thinking level
+        // Note: Gemini 3 Pro only supports 'low' and 'high' thinking levels
+        const config = {};
+        if (thinkingLevel) {
+            // For Pro, only 'low' and 'high' are valid - map 'minimal' and 'medium' appropriately
+            const proThinkingLevel = thinkingLevel === 'minimal' || thinkingLevel === 'low' ? 'low' : 'high';
+            config.thinkingConfig = { thinkingLevel: proThinkingLevel };
+            logger.debug(`Using thinking level: ${proThinkingLevel} (requested: ${thinkingLevel})`);
+        }
+        const response = await genAI.models.generateContent({
+            model: proModelName,
+            contents: prompt,
+            config: Object.keys(config).length > 0 ? config : undefined,
+        });
+        const responseText = response.text || '';
+        logger.response(responseText);
+        return responseText;
+    }
+    catch (error) {
+        logger.error('Error generating content with Gemini Pro:', error);
+        throw error;
+    }
+}
+/**
+ * Generate content using the Gemini Flash model
+ *
+ * @param prompt - The prompt to send to Gemini
+ * @param options - Generation options including thinking level
+ * @returns The generated text response
+ *
+ * Gemini 3 Flash supports ALL thinking levels: minimal, low, medium, high (default)
+ */
+export async function generateWithGeminiFlash(prompt, options = {}) {
+    try {
+        logger.prompt(prompt);
+        const { thinkingLevel } = options;
+        // Build config with optional thinking level
+        // Note: Gemini 3 Flash supports all thinking levels
+        const config = {};
+        if (thinkingLevel) {
+            config.thinkingConfig = { thinkingLevel };
+            logger.debug(`Using thinking level: ${thinkingLevel}`);
+        }
+        const response = await genAI.models.generateContent({
+            model: flashModelName,
+            contents: prompt,
+            config: Object.keys(config).length > 0 ? config : undefined,
+        });
+        const responseText = response.text || '';
+        logger.response(responseText);
+        return responseText;
+    }
+    catch (error) {
+        logger.error('Error generating content with Gemini Flash:', error);
+        throw error;
+    }
+}
+/**
+ * Generate content with a structured chat history
+ */
+export async function generateWithChat(messages, useProModel = true) {
+    try {
+        const model = useProModel ? proModelName : flashModelName;
+        // Format messages for the Gemini API
+        const formattedContents = messages.map((msg) => ({
+            role: msg.role === 'user' ? 'user' : 'model',
+            parts: [{ text: msg.content }],
+        }));
+        logger.debug('Starting chat with messages:', JSON.stringify(messages, null, 2));
+        // Handle the conversation based on the last message
+        const lastMessage = messages[messages.length - 1];
+        if (lastMessage.role === 'user') {
+            logger.prompt(lastMessage.content);
+            // Generate content with the conversation history
+            const response = await genAI.models.generateContent({
+                model: model,
+                contents: formattedContents,
+            });
+            const responseText = response.text || '';
+            logger.response(responseText);
+            return responseText;
+        }
+        else {
+            // If the last message is from the model, we don't need to send anything
+            return lastMessage.content;
+        }
+    }
+    catch (error) {
+        logger.error('Error generating content with chat:', error);
+        throw error;
+    }
+}
+/**
+ * Generate an image using Gemini's Nano Banana Pro model (gemini-3-pro-image-preview)
+ *
+ * Features:
+ * - 4K resolution support (1K, 2K, 4K)
+ * - 10 aspect ratios (1:1, 2:3, 3:2, 3:4, 4:3, 4:5, 5:4, 9:16, 16:9, 21:9)
+ * - Google Search grounding for real-world accuracy
+ * - High-fidelity text rendering
+ */
+export async function generateImage(prompt, options = {}) {
+    try {
+        const { aspectRatio = '1:1', imageSize = '2K', // Default to 2K for good balance of quality and speed
+        style, saveToFile = true, useGoogleSearch = false, } = options;
+        // Build the full prompt with style if provided
+        const fullPrompt = style ? `${prompt}, in ${style} style` : prompt;
+        logger.prompt(`Image generation: ${fullPrompt}`);
+        logger.debug(`Image config: ${aspectRatio}, ${imageSize}, search: ${useGoogleSearch}`);
+        // Build the config for Nano Banana Pro
+        const config = {
+            responseModalities: [Modality.TEXT, Modality.IMAGE],
+            imageConfig: {
+                aspectRatio,
+                imageSize,
+            },
+        };
+        // Add Google Search grounding if requested
+        if (useGoogleSearch) {
+            config.tools = [{ googleSearch: {} }];
+        }
+        const response = await genAI.models.generateContent({
+            model: imageModelName,
+            contents: fullPrompt,
+            config,
+        });
+        // Extract image from response
+        const candidates = response.candidates;
+        if (!candidates || candidates.length === 0) {
+            throw new Error('No candidates in image generation response');
+        }
+        const parts = candidates[0].content?.parts;
+        if (!parts) {
+            throw new Error('No parts in image generation response');
+        }
+        let imageData;
+        let mimeType = 'image/png';
+        let description;
+        for (const part of parts) {
+            if (part.inlineData) {
+                imageData = part.inlineData.data;
+                mimeType = part.inlineData.mimeType || 'image/png';
+            }
+            else if (part.text) {
+                description = part.text;
+            }
+        }
+        if (!imageData) {
+            throw new Error('No image data in response');
+        }
+        // Save to file if requested
+        let filePath = '';
+        if (saveToFile) {
+            const timestamp = Date.now();
+            const extension = mimeType.split('/')[1] || 'png';
+            const filename = `image-${timestamp}.${extension}`;
+            filePath = path.join(outputDir, filename);
+            const buffer = Buffer.from(imageData, 'base64');
+            fs.writeFileSync(filePath, buffer);
+            logger.info(`Image saved to: ${filePath}`);
+        }
+        logger.response(`Image generated successfully (${mimeType})`);
+        return {
+            base64: imageData,
+            mimeType,
+            filePath,
+            description,
+        };
+    }
+    catch (error) {
+        logger.error('Error generating image:', error);
+        throw error;
+    }
+}
+// Store active video operations for polling
+const activeVideoOperations = new Map();
+/**
+ * Start video generation using Gemini's Veo model
+ * Returns an operation that can be polled for completion
+ */
+export async function startVideoGeneration(prompt, options = {}) {
+    try {
+        const { aspectRatio = '16:9', negativePrompt } = options;
+        logger.prompt(`Video generation: ${prompt}`);
+        const config = {
+            aspectRatio,
+        };
+        if (negativePrompt) {
+            config.negativePrompt = negativePrompt;
+        }
+        const operation = await genAI.models.generateVideos({
+            model: videoModelName,
+            prompt,
+            config,
+        });
+        const operationName = operation.name || `video-${Date.now()}`;
+        // Store the full operation object for later polling
+        activeVideoOperations.set(operationName, operation);
+        logger.info(`Video generation started: ${operationName}`);
+        return {
+            operationName,
+            status: 'pending',
+        };
+    }
+    catch (error) {
+        logger.error('Error starting video generation:', error);
+        throw error;
+    }
+}
+/**
+ * Check the status of a video generation operation
+ */
+export async function checkVideoStatus(operationName) {
+    try {
+        logger.debug(`Checking video status: ${operationName}`);
+        // Get the stored operation object
+        let operation = activeVideoOperations.get(operationName);
+        if (!operation) {
+            return {
+                operationName,
+                status: 'failed',
+                error: 'Operation not found. It may have expired or the server was restarted.',
+            };
+        }
+        // Poll for updated status
+        const status = await genAI.operations.getVideosOperation({
+            operation: operation,
+        });
+        // Update stored operation
+        activeVideoOperations.set(operationName, status);
+        if (status.done) {
+            // Clean up stored operation
+            activeVideoOperations.delete(operationName);
+            if (status.error) {
+                return {
+                    operationName,
+                    status: 'failed',
+                    error: String(status.error) || 'Unknown error',
+                };
+            }
+            // Video is ready - get the URI
+            const videoUri = status.response?.generatedVideos?.[0]?.video?.uri;
+            let filePath;
+            if (videoUri) {
+                // Download and save the video
+                const timestamp = Date.now();
+                const filename = `video-${timestamp}.mp4`;
+                filePath = path.join(outputDir, filename);
+                try {
+                    // Fetch the video with API key in header
+                    const response = await fetch(videoUri, {
+                        headers: {
+                            'x-goog-api-key': process.env.GEMINI_API_KEY || '',
+                        },
+                    });
+                    if (response.ok) {
+                        const buffer = Buffer.from(await response.arrayBuffer());
+                        fs.writeFileSync(filePath, buffer);
+                        logger.info(`Video saved to: ${filePath}`);
+                    }
+                    else {
+                        logger.warn(`Failed to download video: ${response.status}`);
+                        filePath = undefined;
+                    }
+                }
+                catch (downloadError) {
+                    logger.warn('Failed to download video:', downloadError);
+                    filePath = undefined;
+                }
+            }
+            return {
+                operationName,
+                status: 'completed',
+                videoUri,
+                filePath,
+            };
+        }
+        return {
+            operationName,
+            status: 'processing',
+        };
+    }
+    catch (error) {
+        logger.error('Error checking video status:', error);
+        throw error;
+    }
+}
+/**
+ * Get the output directory path
+ */
+export function getOutputDir() {
+    return outputDir;
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * MCP Server Gemini - Integrates Google's Gemini models with Claude Code
+ *
+ * This MCP server provides access to Gemini models for use in Claude Code.
+ * Features include direct queries, brainstorming, and analysis tools.
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+/**
+ * MCP Server Gemini - Integrates Google's Gemini models with Claude Code
+ *
+ * This MCP server provides access to Gemini models for use in Claude Code.
+ * Features include direct queries, brainstorming, and analysis tools.
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { parseArgs } from 'node:util';
+// Import tools
+import { registerQueryTool } from './tools/query.js';
+import { registerBrainstormTool } from './tools/brainstorm.js';
+import { registerAnalyzeTool } from './tools/analyze.js';
+import { registerSummarizeTool } from './tools/summarize.js';
+import { registerImageGenTool } from './tools/image-gen.js';
+import { registerImageEditTool } from './tools/image-edit.js';
+import { registerVideoGenTool } from './tools/video-gen.js';
+import { registerCodeExecTool } from './tools/code-exec.js';
+import { registerSearchTool } from './tools/search.js';
+import { registerStructuredTool } from './tools/structured.js';
+import { registerYouTubeTool } from './tools/youtube.js';
+import { registerDocumentTool } from './tools/document.js';
+import { registerUrlContextTool } from './tools/url-context.js';
+import { registerCacheTool } from './tools/cache.js';
+import { registerSpeechTool } from './tools/speech.js';
+// Import Gemini client and logger
+import { initGeminiClient } from './gemini-client.js';
+import { setupLogger, logger } from './utils/logger.js';
+// Parse command line arguments
+const { values } = parseArgs({
+    options: {
+        verbose: {
+            type: 'boolean',
+            short: 'v',
+            default: false,
+        },
+        quiet: {
+            type: 'boolean',
+            short: 'q',
+            default: false,
+        },
+        help: {
+            type: 'boolean',
+            short: 'h',
+            default: false,
+        },
+    },
+});
+// Show help if requested
+if (values.help) {
+    console.log(`
+MCP Server Gemini - Integrates Google's Gemini models with Claude Code
+
+Usage:
+  gemini-mcp [options]
+
+Options:
+  -v, --verbose    Enable verbose logging (shows all prompts and responses)
+  -q, --quiet      Run in quiet mode (minimal logging)
+  -h, --help       Show this help message
+
+Environment Variables:
+  GEMINI_API_KEY   (required) Your Google Gemini API key
+  VERBOSE          (optional) Set to "true" to enable verbose logging
+  QUIET            (optional) Set to "true" to enable quiet mode
+  GEMINI_MODEL     (optional) Default Gemini model to use
+  GEMINI_PRO_MODEL (optional) Specify Pro model variant
+  GEMINI_FLASH_MODEL (optional) Specify Flash model variant
+  `);
+    process.exit(0);
+}
+// Configure logging mode based on command line args or environment variables
+let logLevel = 'normal';
+if (values.verbose || process.env.VERBOSE === 'true') {
+    logLevel = 'verbose';
+}
+else if (values.quiet || process.env.QUIET === 'true') {
+    logLevel = 'quiet';
+}
+setupLogger(logLevel);
+// Check for required API key
+if (!process.env.GEMINI_API_KEY) {
+    logger.error('Error: GEMINI_API_KEY environment variable is required');
+    process.exit(1);
+}
+// Get model name from environment or use default
+// Use Gemini 3 as default (latest frontier model)
+const defaultModel = 'gemini-3-pro-preview';
+const geminiModel = process.env.GEMINI_MODEL || defaultModel;
+// Log model configuration for debugging
+logger.debug(`Model configuration:
+  - GEMINI_MODEL: ${process.env.GEMINI_MODEL || '(not set, using default)'}
+  - GEMINI_PRO_MODEL: ${process.env.GEMINI_PRO_MODEL || '(not set, using default)'}
+  - GEMINI_FLASH_MODEL: ${process.env.GEMINI_FLASH_MODEL || '(not set, using default)'}`);
+async function main() {
+    logger.info(`Starting MCP Gemini Server with model: ${geminiModel}`);
+    logger.info(`Logging mode: ${logLevel}`);
+    // Handle unexpected stdio errors
+    process.stdin.on('error', (err) => {
+        logger.error('STDIN error:', err);
+        // Don't exit, just log
+    });
+    process.stdout.on('error', (err) => {
+        logger.error('STDOUT error:', err);
+        // Don't exit, just log
+    });
+    try {
+        // Initialize Gemini client
+        await initGeminiClient();
+        // Create MCP server
+        const server = new McpServer({
+            name: 'Gemini',
+            version: '0.5.0',
+        });
+        // Register tools
+        registerQueryTool(server);
+        registerBrainstormTool(server);
+        registerAnalyzeTool(server);
+        registerSummarizeTool(server);
+        registerImageGenTool(server);
+        registerImageEditTool(server);
+        registerVideoGenTool(server);
+        registerCodeExecTool(server);
+        registerSearchTool(server);
+        registerStructuredTool(server);
+        registerYouTubeTool(server);
+        registerDocumentTool(server);
+        registerUrlContextTool(server);
+        registerCacheTool(server);
+        registerSpeechTool(server);
+        // Start server with stdio transport with enhanced error handling
+        const transport = new StdioServerTransport();
+        // Set up error handling for transport with improved error recovery
+        transport.onclose = () => {
+            logger.warn('MCP transport connection closed');
+            logger.debug('Connection closed event triggered');
+            // Attempt to recover connection after brief delay with backoff strategy
+            let reconnectAttempts = 0;
+            const maxReconnectAttempts = 5;
+            const attemptReconnect = () => {
+                if (reconnectAttempts >= maxReconnectAttempts) {
+                    logger.error(`Failed to reconnect after ${maxReconnectAttempts} attempts`);
+                    return;
+                }
+                reconnectAttempts++;
+                const delay = Math.min(1000 * Math.pow(1.5, reconnectAttempts - 1), 10000);
+                logger.info(`Attempting to reconnect (${reconnectAttempts}/${maxReconnectAttempts}) after ${delay}ms...`);
+                setTimeout(() => {
+                    try {
+                        // Check if stdin/stdout are still available
+                        if (process.stdin.destroyed || process.stdout.destroyed) {
+                            logger.error('Cannot reconnect: stdin or stdout is destroyed');
+                            return;
+                        }
+                        server.connect(transport)
+                            .then(() => {
+                            logger.info('Successfully reconnected to MCP transport');
+                            reconnectAttempts = 0;
+                        })
+                            .catch(e => {
+                            logger.error('Reconnection failed:', e);
+                            attemptReconnect(); // Try again with backoff
+                        });
+                    }
+                    catch (e) {
+                        logger.error('Error during reconnection attempt:', e);
+                        attemptReconnect(); // Try again with backoff
+                    }
+                }, delay);
+            };
+            attemptReconnect();
+        };
+        transport.onerror = (error) => {
+            logger.error('MCP transport error:', error);
+            // Log detailed error information for debugging
+            if (error instanceof Error) {
+                logger.debug(`Error name: ${error.name}, message: ${error.message}`);
+                logger.debug(`Stack trace: ${error.stack}`);
+            }
+        };
+        // Set up error handling for the connection with more diagnostics
+        try {
+            // Log environment diagnostic info before connecting
+            logger.debug(`Process details - PID: ${process.pid}, Node version: ${process.version}`);
+            logger.debug(`Environment variables: API_KEY=${process.env.GEMINI_API_KEY ? 'SET' : 'NOT_SET'}, VERBOSE=${process.env.VERBOSE || 'not set'}`);
+            logger.debug(`Process stdin/stdout state - isTTY: ${process.stdin.isTTY}, ${process.stdout.isTTY}`);
+            await server.connect(transport);
+            logger.info('MCP Gemini Server running');
+        }
+        catch (err) {
+            logger.error('Failed to connect MCP server transport:', err);
+            // More detailed error logging
+            if (err instanceof Error) {
+                logger.debug(`Error stack: ${err.stack}`);
+                logger.debug(`Error details: name=${err.name}, message=${err.message}`);
+            }
+            else {
+                logger.debug(`Non-Error object thrown: ${JSON.stringify(err)}`);
+            }
+            logger.warn('Server will attempt to continue running despite connection error');
+        }
+        // Handle process termination
+        process.on('SIGINT', async () => {
+            logger.info('Shutting down MCP Gemini Server');
+            await server.close();
+            process.exit(0);
+        });
+        process.on('SIGTERM', async () => {
+            logger.info('Shutting down MCP Gemini Server');
+            await server.close();
+            process.exit(0);
+        });
+    }
+    catch (error) {
+        logger.error('Failed to start MCP Gemini Server:', error);
+        process.exit(1);
+    }
+}
+main();

package/dist/tools/analyze.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Analyze Tool - Provides analysis capabilities using Gemini models
+ *
+ * This tool allows analyzing code, text, or specific content with Gemini.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/**
+ * Register analysis tools with the MCP server
+ */
+export declare function registerAnalyzeTool(server: McpServer): void;