@rlabs-inc/gemini-mcp 0.5.0

package/dist/tools/analyze.js

@@ -0,0 +1,96 @@
+/**
+ * Analyze Tool - Provides analysis capabilities using Gemini models
+ *
+ * This tool allows analyzing code, text, or specific content with Gemini.
+ */
+import { z } from "zod";
+import { generateWithGeminiPro } from "../gemini-client.js";
+/**
+ * Register analysis tools with the MCP server
+ */
+export function registerAnalyzeTool(server) {
+    // Code analysis tool
+    server.tool("gemini-analyze-code", {
+        code: z.string().describe("The code to analyze"),
+        language: z.string().optional().describe("The programming language of the code"),
+        focus: z.enum(["quality", "security", "performance", "bugs", "general"]).default("general").describe("What aspect to focus the analysis on")
+    }, async ({ code, language, focus }) => {
+        console.log(`Analyzing code with focus on ${focus}`);
+        try {
+            const langText = language ? `${language} code` : "code";
+            const prompt = `
+Analyze the following ${langText} with a focus on ${focus}:
+
+\`\`\`${language ? language : ""}
+${code}
+\`\`\`
+
+Please provide:
+${focus === "quality" ? "1. Code quality assessment\n2. Style and readability review\n3. Maintainability considerations\n4. Suggested improvements" : ""}
+${focus === "security" ? "1. Security vulnerabilities identification\n2. Potential exploit vectors\n3. Security best practices assessment\n4. Security improvements" : ""}
+${focus === "performance" ? "1. Performance bottlenecks\n2. Optimization opportunities\n3. Algorithmic complexity analysis\n4. Performance improvement suggestions" : ""}
+${focus === "bugs" ? "1. Bugs and logical errors\n2. Edge cases that aren't handled\n3. Potential runtime errors\n4. Bug fix suggestions" : ""}
+${focus === "general" ? "1. Overall code assessment\n2. Strengths and weaknesses\n3. Potential issues (bugs, security, performance)\n4. Suggested improvements" : ""}
+`;
+            const response = await generateWithGeminiPro(prompt);
+            return {
+                content: [{
+                        type: "text",
+                        text: response
+                    }]
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`Error analyzing code: ${errorMessage}`);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error: ${errorMessage}`
+                    }],
+                isError: true
+            };
+        }
+    });
+    // Text analysis tool
+    server.tool("gemini-analyze-text", {
+        text: z.string().describe("The text to analyze"),
+        type: z.enum(["sentiment", "summary", "entities", "key-points", "general"]).default("general").describe("Type of analysis to perform")
+    }, async ({ text, type }) => {
+        console.log(`Analyzing text with focus on ${type}`);
+        try {
+            const prompt = `
+Analyze the following text with a focus on ${type}:
+
+"""
+${text}
+"""
+
+Please provide:
+${type === "sentiment" ? "1. Overall sentiment (positive, negative, neutral)\n2. Sentiment intensity\n3. Key emotional elements\n4. Sentiment by topic/section if applicable" : ""}
+${type === "summary" ? "1. Concise summary of the main points\n2. Key takeaways\n3. Important details\n4. Context and implications" : ""}
+${type === "entities" ? "1. People mentioned\n2. Organizations mentioned\n3. Locations mentioned\n4. Other notable entities (products, events, etc.)" : ""}
+${type === "key-points" ? "1. Main arguments or claims\n2. Supporting evidence\n3. Conclusions reached\n4. Logical structure analysis" : ""}
+${type === "general" ? "1. Overall summary\n2. Key themes and topics\n3. Tone and style assessment\n4. Notable insights and implications" : ""}
+`;
+            const response = await generateWithGeminiPro(prompt);
+            return {
+                content: [{
+                        type: "text",
+                        text: response
+                    }]
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`Error analyzing text: ${errorMessage}`);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error: ${errorMessage}`
+                    }],
+                isError: true
+            };
+        }
+    });
+}

package/dist/tools/brainstorm.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Brainstorm Tool - Enables automatic collaborative brainstorming between Claude and Gemini
+ *
+ * This tool facilitates multi-round collaborative planning until consensus is reached.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/**
+ * Register brainstorm tool with the MCP server
+ */
+export declare function registerBrainstormTool(server: McpServer): void;

package/dist/tools/brainstorm.js

@@ -0,0 +1,220 @@
+/**
+ * Brainstorm Tool - Enables automatic collaborative brainstorming between Claude and Gemini
+ *
+ * This tool facilitates multi-round collaborative planning until consensus is reached.
+ */
+import { z } from "zod";
+import { generateWithGeminiPro } from "../gemini-client.js";
+import { logger } from "../utils/logger.js";
+/**
+ * Register brainstorm tool with the MCP server
+ */
+export function registerBrainstormTool(server) {
+    server.tool("gemini-brainstorm", {
+        prompt: z.string().describe("The problem statement or query to brainstorm about"),
+        maxRounds: z.number().int().min(1).max(5).default(3).describe("Maximum number of brainstorming rounds"),
+        claudeThoughts: z.string().describe("Claude's initial thoughts on the problem")
+    }, async ({ prompt, maxRounds = 3, claudeThoughts }) => {
+        logger.info(`Starting consensus-building brainstorm with Gemini: ${prompt.substring(0, 50)}...`);
+        try {
+            // Set up conversation tracking
+            const rounds = [];
+            let currentRound = 1;
+            let consensusReached = false;
+            // First round - Gemini responds to Claude's initial thoughts
+            const firstRoundPrompt = `
+You're collaborating with Claude (another AI assistant) to address this user request:
+
+---
+${prompt}
+---
+
+Claude has shared these initial thoughts:
+${claudeThoughts}
+
+Analyze Claude's thoughts and respond with:
+1. Points of agreement
+2. Additional insights or perspectives
+3. Any modifications to Claude's approach
+4. Next steps to implement the solution
+
+End your response with a "Consensus Score" from 1-10 indicating how aligned you are with Claude:
+- 1-3: Significant differences in approach
+- 4-6: Partial agreement with key differences
+- 7-9: Strong alignment with minor refinements
+- 10: Complete consensus
+
+Format this as: "Consensus Score: [NUMBER]"
+`;
+            const geminiFirstResponse = await generateWithGeminiPro(firstRoundPrompt);
+            // Extract consensus score 
+            const consensusMatch = geminiFirstResponse.match(/Consensus Score:\s*(\d+)/i);
+            const consensusScore = consensusMatch ? parseInt(consensusMatch[1], 10) : 0;
+            // Record first round
+            rounds.push({
+                number: currentRound,
+                claudeThoughts: claudeThoughts,
+                geminiResponse: geminiFirstResponse,
+                consensusScore: consensusScore
+            });
+            // Check if we already have consensus
+            if (consensusScore >= 8) {
+                logger.info(`Consensus reached in first round with score ${consensusScore}`);
+                consensusReached = true;
+            }
+            // Continue with additional rounds if needed
+            currentRound++;
+            let lastClaudeThoughts = claudeThoughts;
+            let lastGeminiResponse = geminiFirstResponse;
+            while (currentRound <= maxRounds && !consensusReached) {
+                // Generate Claude's response to Gemini (using Gemini to simulate)
+                const simulateClaudePrompt = `
+You will simulate Claude's response in our brainstorming process about this request:
+
+---
+${prompt}
+---
+
+Previous exchange:
+1. Claude's initial thoughts: 
+${lastClaudeThoughts.substring(0, 300)}${lastClaudeThoughts.length > 300 ? '...' : ''}
+
+2. Your (Gemini's) response: 
+${lastGeminiResponse}
+
+As Claude, respond to Gemini's message. Use Claude's communication style:
+1. Analytical, thoughtful, and balanced
+2. Precise and well-structured
+3. Careful about implementation details
+4. Focused on understanding nuance
+
+Include areas of agreement, further refinements, and a path forward.
+
+End your response with a "Consensus Score" from 1-10:
+- 1-3: Significant differences remain
+- 4-6: Closer alignment but key differences exist
+- 7-9: Strong alignment with minor refinements
+- 10: Complete consensus
+
+Format: "Consensus Score: [NUMBER]"
+`;
+                const simulatedClaudeResponse = await generateWithGeminiPro(simulateClaudePrompt);
+                // Extract consensus score
+                const claudeConsensusMatch = simulatedClaudeResponse.match(/Consensus Score:\s*(\d+)/i);
+                const claudeConsensusScore = claudeConsensusMatch ? parseInt(claudeConsensusMatch[1], 10) : 0;
+                // Generate Gemini's response to Claude
+                const geminiFollowUpPrompt = `
+Continuing our collaboration with Claude on this request:
+
+---
+${prompt}
+---
+
+Latest exchange:
+1. Your previous response: 
+${lastGeminiResponse.substring(0, 300)}${lastGeminiResponse.length > 300 ? '...' : ''}
+
+2. Claude's latest thoughts: 
+${simulatedClaudeResponse}
+
+Respond to Claude's latest message, focusing on:
+1. Addressing any remaining differences
+2. Building on areas of agreement
+3. Moving toward a final consensus solution
+4. Clarifying implementation details
+
+End your response with a "Consensus Score" from 1-10:
+- 1-3: Significant differences remain
+- 4-6: Closer alignment but key differences exist
+- 7-9: Strong alignment with minor refinements
+- 10: Complete consensus
+
+Format: "Consensus Score: [NUMBER]"
+`;
+                const geminiResponse = await generateWithGeminiPro(geminiFollowUpPrompt);
+                // Extract consensus score
+                const geminiConsensusMatch = geminiResponse.match(/Consensus Score:\s*(\d+)/i);
+                const geminiConsensusScore = geminiConsensusMatch ? parseInt(geminiConsensusMatch[1], 10) : 0;
+                // Record this round
+                rounds.push({
+                    number: currentRound,
+                    claudeThoughts: simulatedClaudeResponse,
+                    geminiResponse: geminiResponse,
+                    consensusScore: geminiConsensusScore
+                });
+                // Check if we've reached consensus
+                if (geminiConsensusScore >= 8 || claudeConsensusScore >= 8) {
+                    logger.info(`Consensus reached in round ${currentRound} with score ${geminiConsensusScore}`);
+                    consensusReached = true;
+                }
+                // Update for next round
+                lastClaudeThoughts = simulatedClaudeResponse;
+                lastGeminiResponse = geminiResponse;
+                currentRound++;
+            }
+            // Generate final synthesis of the conversation
+            const synthesisPrompt = `
+You've completed a collaborative brainstorming session with Claude about:
+
+---
+${prompt}
+---
+
+Here's the conversation history:
+${rounds.map(round => `
+Round ${round.number}:
+- Claude: ${round.claudeThoughts.substring(0, 250)}${round.claudeThoughts.length > 250 ? '...' : ''}
+- Gemini: ${round.geminiResponse.substring(0, 250)}${round.geminiResponse.length > 250 ? '...' : ''}
+- Consensus Score: ${round.consensusScore}/10
+`).join('\n')}
+
+Create a comprehensive synthesis that Claude can implement:
+1. A clear summary of the approach both AIs agreed upon
+2. A specific, actionable plan addressing the user's request
+3. Key implementation details and considerations
+4. Any technical requirements or resources needed
+5. Next steps for Claude to execute
+
+Your synthesis should be structured, thorough, and ready for Claude to implement.
+`;
+            const finalSynthesis = await generateWithGeminiPro(synthesisPrompt);
+            // Format the conversation history
+            const conversationHistory = rounds.map(round => `
+## Round ${round.number}
+
+### Claude's Thoughts
+${round.claudeThoughts}
+
+### Gemini's Response
+${round.geminiResponse}
+
+**Consensus Score: ${round.consensusScore}/10**
+`).join('\n\n---\n\n');
+            // Return the final result
+            return {
+                content: [{
+                        type: "text",
+                        text: `# Collaborative Solution: ${prompt.substring(0, 50)}...
+
+## Final Synthesis
+${finalSynthesis}
+
+${consensusReached
+                            ? `\n\n*Consensus reached after ${rounds.length} rounds of collaboration.*`
+                            : `\n\n*Maximum rounds (${maxRounds}) reached. Providing best synthesis.*`}
+
+## Conversation History
+${conversationHistory}`
+                    }]
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error(`Error in brainstorming: ${errorMessage}`);
+            return {
+                content: [{ type: "text", text: `Error: ${errorMessage}` }],
+                isError: true
+            };
+        }
+    });
+}

package/dist/tools/cache.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Context Caching Tool - Cache large content for cost savings
+ *
+ * When working with large documents or videos repeatedly, caching saves costs
+ * by storing the tokenized content and reusing it across requests.
+ *
+ * Useful for:
+ * - Chatbots with extensive system instructions
+ * - Repetitive analysis of large files
+ * - Recurring queries against document sets
+ * - Code repository analysis
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Register caching tools with the MCP server
+ */
+export declare function registerCacheTool(server: McpServer): void;

package/dist/tools/cache.js

@@ -0,0 +1,286 @@
+/**
+ * Context Caching Tool - Cache large content for cost savings
+ *
+ * When working with large documents or videos repeatedly, caching saves costs
+ * by storing the tokenized content and reusing it across requests.
+ *
+ * Useful for:
+ * - Chatbots with extensive system instructions
+ * - Repetitive analysis of large files
+ * - Recurring queries against document sets
+ * - Code repository analysis
+ */
+import { z } from 'zod';
+import { GoogleGenAI } from '@google/genai';
+import { logger } from '../utils/logger.js';
+import * as fs from 'fs';
+import * as path from 'path';
+// Store active caches for reference
+const activeCaches = new Map();
+/**
+ * Get MIME type from file extension
+ */
+function getMimeType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const mimeTypes = {
+        '.pdf': 'application/pdf',
+        '.txt': 'text/plain',
+        '.csv': 'text/csv',
+        '.mp4': 'video/mp4',
+        '.mov': 'video/mov',
+        '.avi': 'video/avi',
+        '.webm': 'video/webm',
+    };
+    return mimeTypes[ext] || 'application/octet-stream';
+}
+/**
+ * Register caching tools with the MCP server
+ */
+export function registerCacheTool(server) {
+    // Create a cache from a file
+    server.tool('gemini-create-cache', {
+        filePath: z.string().describe('Path to the file to cache'),
+        displayName: z.string().describe('A name to identify this cache'),
+        systemInstruction: z
+            .string()
+            .optional()
+            .describe('System instruction to include with the cache'),
+        ttlMinutes: z
+            .number()
+            .min(1)
+            .max(1440)
+            .default(60)
+            .describe('Time to live in minutes (1-1440, default 60)'),
+    }, async ({ filePath, displayName, systemInstruction, ttlMinutes }) => {
+        logger.info(`Creating cache: ${displayName}`);
+        try {
+            const apiKey = process.env.GEMINI_API_KEY;
+            if (!apiKey) {
+                throw new Error('GEMINI_API_KEY not set');
+            }
+            if (!fs.existsSync(filePath)) {
+                throw new Error(`File not found: ${filePath}`);
+            }
+            const genAI = new GoogleGenAI({ apiKey });
+            // Use a specific model version for caching (required)
+            const model = 'gemini-2.0-flash-001';
+            // Upload the file first
+            const fileBuffer = fs.readFileSync(filePath);
+            const mimeType = getMimeType(filePath);
+            logger.info(`Uploading file: ${filePath} (${mimeType})`);
+            const uploadedFile = await genAI.files.upload({
+                file: new Blob([fileBuffer], { type: mimeType }),
+                config: { mimeType },
+            });
+            // Create the cache
+            const cacheConfig = {
+                displayName,
+                contents: [
+                    {
+                        parts: [
+                            {
+                                fileData: {
+                                    fileUri: uploadedFile.uri,
+                                    mimeType: uploadedFile.mimeType,
+                                },
+                            },
+                        ],
+                    },
+                ],
+                ttl: `${ttlMinutes * 60}s`,
+            };
+            if (systemInstruction) {
+                cacheConfig.systemInstruction = systemInstruction;
+            }
+            const cache = await genAI.caches.create({
+                model,
+                config: cacheConfig,
+            });
+            // Store cache info
+            const expireTime = new Date(Date.now() + ttlMinutes * 60 * 1000);
+            activeCaches.set(displayName, {
+                name: cache.name || displayName,
+                model,
+                displayName,
+                expireTime,
+            });
+            logger.info(`Cache created: ${cache.name}`);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Cache created successfully!\n\n**Name:** ${cache.name}\n**Display Name:** ${displayName}\n**Model:** ${model}\n**Expires:** ${expireTime.toISOString()}\n\nUse gemini-query-cache with this cache name to query the cached content.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error(`Error creating cache: ${errorMessage}`);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error creating cache: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Query using a cached content
+    server.tool('gemini-query-cache', {
+        cacheName: z.string().describe('The cache name or display name'),
+        question: z.string().describe('Question to ask about the cached content'),
+    }, async ({ cacheName, question }) => {
+        logger.info(`Querying cache: ${cacheName}`);
+        try {
+            const apiKey = process.env.GEMINI_API_KEY;
+            if (!apiKey) {
+                throw new Error('GEMINI_API_KEY not set');
+            }
+            const genAI = new GoogleGenAI({ apiKey });
+            // Look up cache by display name or use as-is
+            const cacheInfo = activeCaches.get(cacheName);
+            const actualCacheName = cacheInfo?.name || cacheName;
+            const model = cacheInfo?.model || 'gemini-2.0-flash-001';
+            // Query with cached content
+            const response = await genAI.models.generateContent({
+                model,
+                contents: question,
+                config: {
+                    cachedContent: actualCacheName,
+                },
+            });
+            const usageMetadata = response.usageMetadata;
+            let usageInfo = '';
+            if (usageMetadata) {
+                usageInfo = `\n\n---\n**Token Usage:**\n`;
+                usageInfo += `- Total: ${usageMetadata.totalTokenCount || 0}\n`;
+                usageInfo += `- Cached: ${usageMetadata.cachedContentTokenCount || 0}\n`;
+                usageInfo += `- New prompt: ${usageMetadata.promptTokenCount || 0}\n`;
+                usageInfo += `- Response: ${usageMetadata.candidatesTokenCount || 0}`;
+            }
+            logger.info('Cache query completed');
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: (response.text || 'No response.') + usageInfo,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error(`Error querying cache: ${errorMessage}`);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error querying cache: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // List active caches
+    server.tool('gemini-list-caches', {}, async () => {
+        logger.info('Listing caches');
+        try {
+            const apiKey = process.env.GEMINI_API_KEY;
+            if (!apiKey) {
+                throw new Error('GEMINI_API_KEY not set');
+            }
+            const genAI = new GoogleGenAI({ apiKey });
+            // Get caches from API
+            const caches = [];
+            const cacheList = await genAI.caches.list();
+            if (cacheList && Array.isArray(cacheList)) {
+                for (const cache of cacheList) {
+                    caches.push(cache);
+                }
+            }
+            if (caches.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'No active caches found.\n\nCreate one with gemini-create-cache.',
+                        },
+                    ],
+                };
+            }
+            let text = '**Active Caches:**\n\n';
+            for (const cache of caches) {
+                text += `- **${cache.displayName || cache.name}**\n`;
+                text += `  - Name: ${cache.name}\n`;
+                text += `  - Model: ${cache.model}\n`;
+                text += `  - Expires: ${cache.expireTime}\n\n`;
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error(`Error listing caches: ${errorMessage}`);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error listing caches: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Delete a cache
+    server.tool('gemini-delete-cache', {
+        cacheName: z.string().describe('The cache name to delete'),
+    }, async ({ cacheName }) => {
+        logger.info(`Deleting cache: ${cacheName}`);
+        try {
+            const apiKey = process.env.GEMINI_API_KEY;
+            if (!apiKey) {
+                throw new Error('GEMINI_API_KEY not set');
+            }
+            const genAI = new GoogleGenAI({ apiKey });
+            // Look up by display name
+            const cacheInfo = activeCaches.get(cacheName);
+            const actualCacheName = cacheInfo?.name || cacheName;
+            await genAI.caches.delete({ name: actualCacheName });
+            // Remove from local tracking
+            activeCaches.delete(cacheName);
+            logger.info('Cache deleted');
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Cache "${cacheName}" deleted successfully.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error(`Error deleting cache: ${errorMessage}`);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error deleting cache: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/code-exec.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Code Execution Tool - Let Gemini write and run Python code
+ *
+ * This tool enables Gemini to generate and execute Python code in a sandboxed environment.
+ * Useful for:
+ * - Data analysis with pandas
+ * - Math computations
+ * - Chart generation with matplotlib
+ * - File processing
+ *
+ * Supported libraries include: numpy, pandas, matplotlib, scipy, scikit-learn, tensorflow, and more.
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Register code execution tools with the MCP server
+ */
+export declare function registerCodeExecTool(server: McpServer): void;