@rlabs-inc/gemini-mcp 0.5.0

package/dist/tools/speech.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Speech Generation Tool - Text-to-Speech with Gemini
+ *
+ * Generate high-quality speech from text using Gemini's native TTS.
+ * Features:
+ * - 30 voice options with different tones and styles
+ * - Multi-speaker support (up to 2 speakers)
+ * - Controllable style, accent, pace via natural language
+ * - 24 language support
+ *
+ * Output: WAV files saved to the output directory
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Register speech generation tools with the MCP server
+ */
+export declare function registerSpeechTool(server: McpServer): void;

package/dist/tools/speech.js

@@ -0,0 +1,304 @@
+/**
+ * Speech Generation Tool - Text-to-Speech with Gemini
+ *
+ * Generate high-quality speech from text using Gemini's native TTS.
+ * Features:
+ * - 30 voice options with different tones and styles
+ * - Multi-speaker support (up to 2 speakers)
+ * - Controllable style, accent, pace via natural language
+ * - 24 language support
+ *
+ * Output: WAV files saved to the output directory
+ */
+import { z } from 'zod';
+import { GoogleGenAI, Modality } from '@google/genai';
+import { logger } from '../utils/logger.js';
+import * as fs from 'fs';
+import * as path from 'path';
+// Get output directory for generated files
+function getOutputDir() {
+    return (process.env.GEMINI_OUTPUT_DIR || path.join(process.cwd(), 'gemini-output'));
+}
+// Save PCM audio as WAV file
+function saveWavFile(filename, pcmData, channels = 1, sampleRate = 24000, bitsPerSample = 16) {
+    const outputDir = getOutputDir();
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    const filePath = path.join(outputDir, filename);
+    // Create WAV header
+    const byteRate = (sampleRate * channels * bitsPerSample) / 8;
+    const blockAlign = (channels * bitsPerSample) / 8;
+    const dataSize = pcmData.length;
+    const headerSize = 44;
+    const fileSize = headerSize + dataSize - 8;
+    const header = Buffer.alloc(headerSize);
+    // RIFF header
+    header.write('RIFF', 0);
+    header.writeUInt32LE(fileSize, 4);
+    header.write('WAVE', 8);
+    // fmt chunk
+    header.write('fmt ', 12);
+    header.writeUInt32LE(16, 16); // chunk size
+    header.writeUInt16LE(1, 20); // audio format (PCM)
+    header.writeUInt16LE(channels, 22);
+    header.writeUInt32LE(sampleRate, 24);
+    header.writeUInt32LE(byteRate, 28);
+    header.writeUInt16LE(blockAlign, 32);
+    header.writeUInt16LE(bitsPerSample, 34);
+    // data chunk
+    header.write('data', 36);
+    header.writeUInt32LE(dataSize, 40);
+    // Write file
+    fs.writeFileSync(filePath, Buffer.concat([header, pcmData]));
+    return filePath;
+}
+// Available voices
+const VOICES = [
+    'Zephyr',
+    'Puck',
+    'Charon',
+    'Kore',
+    'Fenrir',
+    'Leda',
+    'Orus',
+    'Aoede',
+    'Callirrhoe',
+    'Autonoe',
+    'Enceladus',
+    'Iapetus',
+    'Umbriel',
+    'Algieba',
+    'Despina',
+    'Erinome',
+    'Algenib',
+    'Rasalgethi',
+    'Laomedeia',
+    'Achernar',
+    'Alnilam',
+    'Schedar',
+    'Gacrux',
+    'Pulcherrima',
+    'Achird',
+    'Zubenelgenubi',
+    'Vindemiatrix',
+    'Sadachbia',
+    'Sadaltager',
+    'Sulafat',
+];
+/**
+ * Register speech generation tools with the MCP server
+ */
+export function registerSpeechTool(server) {
+    // Single speaker TTS
+    server.tool('gemini-speak', {
+        text: z.string().describe('The text to convert to speech'),
+        voice: z
+            .enum(VOICES)
+            .default('Kore')
+            .describe('Voice to use. Popular: Kore (firm), Puck (upbeat), Zephyr (bright), Charon (informative), Aoede (breezy)'),
+        style: z
+            .string()
+            .optional()
+            .describe('Style instructions (e.g., "cheerfully", "in a spooky whisper", "with excitement")'),
+    }, async ({ text, voice, style }) => {
+        logger.info(`Speech generation: ${text.substring(0, 50)}...`);
+        try {
+            const apiKey = process.env.GEMINI_API_KEY;
+            if (!apiKey) {
+                throw new Error('GEMINI_API_KEY not set');
+            }
+            const genAI = new GoogleGenAI({ apiKey });
+            const model = 'gemini-2.5-flash-preview-tts';
+            // Build prompt with optional style
+            const prompt = style ? `Say ${style}: "${text}"` : text;
+            // Generate speech
+            const response = await genAI.models.generateContent({
+                model,
+                contents: [{ parts: [{ text: prompt }] }],
+                config: {
+                    responseModalities: [Modality.AUDIO],
+                    speechConfig: {
+                        voiceConfig: {
+                            prebuiltVoiceConfig: { voiceName: voice },
+                        },
+                    },
+                },
+            });
+            // Extract audio data
+            const audioData = response.candidates?.[0]?.content?.parts?.[0]?.inlineData?.data;
+            if (!audioData) {
+                throw new Error('No audio data in response');
+            }
+            // Save as WAV
+            const audioBuffer = Buffer.from(audioData, 'base64');
+            const timestamp = Date.now();
+            const filename = `speech-${timestamp}.wav`;
+            const filePath = saveWavFile(filename, audioBuffer);
+            logger.info(`Speech saved to: ${filePath}`);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Speech generated successfully!\n\n**Voice:** ${voice}\n**File:** ${filePath}\n**Duration:** ~${Math.round(audioBuffer.length / 48000)}s\n\nThe audio file has been saved and can be played with any audio player.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error(`Error in speech generation: ${errorMessage}`);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error generating speech: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Multi-speaker TTS (for dialogues/podcasts)
+    server.tool('gemini-dialogue', {
+        script: z
+            .string()
+            .describe('The dialogue script with speaker names. Format: "Speaker1: line\\nSpeaker2: line"'),
+        speaker1: z.string().describe('Name of first speaker as used in script'),
+        speaker1Voice: z
+            .enum(VOICES)
+            .default('Kore')
+            .describe('Voice for speaker 1'),
+        speaker2: z.string().describe('Name of second speaker as used in script'),
+        speaker2Voice: z
+            .enum(VOICES)
+            .default('Puck')
+            .describe('Voice for speaker 2'),
+        style: z
+            .string()
+            .optional()
+            .describe('Style instructions for the dialogue (e.g., "Make Speaker1 sound tired, Speaker2 excited")'),
+    }, async ({ script, speaker1, speaker1Voice, speaker2, speaker2Voice, style, }) => {
+        logger.info(`Dialogue generation: ${speaker1} & ${speaker2}`);
+        try {
+            const apiKey = process.env.GEMINI_API_KEY;
+            if (!apiKey) {
+                throw new Error('GEMINI_API_KEY not set');
+            }
+            const genAI = new GoogleGenAI({ apiKey });
+            const model = 'gemini-2.5-flash-preview-tts';
+            // Build prompt
+            let prompt = script;
+            if (style) {
+                prompt = `${style}\n\n${script}`;
+            }
+            // Generate multi-speaker speech
+            const response = await genAI.models.generateContent({
+                model,
+                contents: [{ parts: [{ text: prompt }] }],
+                config: {
+                    responseModalities: [Modality.AUDIO],
+                    speechConfig: {
+                        multiSpeakerVoiceConfig: {
+                            speakerVoiceConfigs: [
+                                {
+                                    speaker: speaker1,
+                                    voiceConfig: {
+                                        prebuiltVoiceConfig: { voiceName: speaker1Voice },
+                                    },
+                                },
+                                {
+                                    speaker: speaker2,
+                                    voiceConfig: {
+                                        prebuiltVoiceConfig: { voiceName: speaker2Voice },
+                                    },
+                                },
+                            ],
+                        },
+                    },
+                },
+            });
+            // Extract audio data
+            const audioData = response.candidates?.[0]?.content?.parts?.[0]?.inlineData?.data;
+            if (!audioData) {
+                throw new Error('No audio data in response');
+            }
+            // Save as WAV
+            const audioBuffer = Buffer.from(audioData, 'base64');
+            const timestamp = Date.now();
+            const filename = `dialogue-${timestamp}.wav`;
+            const filePath = saveWavFile(filename, audioBuffer);
+            logger.info(`Dialogue saved to: ${filePath}`);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Dialogue generated successfully!\n\n**Speakers:**\n- ${speaker1}: ${speaker1Voice}\n- ${speaker2}: ${speaker2Voice}\n\n**File:** ${filePath}\n**Duration:** ~${Math.round(audioBuffer.length / 48000)}s`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error(`Error in dialogue generation: ${errorMessage}`);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error generating dialogue: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // List available voices
+    server.tool('gemini-list-voices', {}, async () => {
+        const voiceDescriptions = {
+            Zephyr: 'Bright',
+            Puck: 'Upbeat',
+            Charon: 'Informative',
+            Kore: 'Firm',
+            Fenrir: 'Excitable',
+            Leda: 'Youthful',
+            Orus: 'Firm',
+            Aoede: 'Breezy',
+            Callirrhoe: 'Easy-going',
+            Autonoe: 'Bright',
+            Enceladus: 'Breathy',
+            Iapetus: 'Clear',
+            Umbriel: 'Easy-going',
+            Algieba: 'Smooth',
+            Despina: 'Smooth',
+            Erinome: 'Clear',
+            Algenib: 'Gravelly',
+            Rasalgethi: 'Informative',
+            Laomedeia: 'Upbeat',
+            Achernar: 'Soft',
+            Alnilam: 'Firm',
+            Schedar: 'Even',
+            Gacrux: 'Mature',
+            Pulcherrima: 'Forward',
+            Achird: 'Friendly',
+            Zubenelgenubi: 'Casual',
+            Vindemiatrix: 'Gentle',
+            Sadachbia: 'Lively',
+            Sadaltager: 'Knowledgeable',
+            Sulafat: 'Warm',
+        };
+        let text = '**Available Voices for Speech Generation:**\n\n';
+        for (const voice of VOICES) {
+            text += `- **${voice}** - ${voiceDescriptions[voice] || ''}\n`;
+        }
+        text +=
+            '\n*Use these voices with gemini-speak or gemini-dialogue tools.*';
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text,
+                },
+            ],
+        };
+    });
+}

package/dist/tools/structured.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Structured Output Tool - Get JSON responses with schema validation
+ *
+ * This tool enables Gemini to generate responses that adhere to a provided JSON Schema.
+ * Useful for:
+ * - Data extraction from unstructured text
+ * - Structured classification
+ * - Generating data for APIs or databases
+ *
+ * Supports combining with Google Search for grounded structured data.
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Register structured output tools with the MCP server
+ */
+export declare function registerStructuredTool(server: McpServer): void;

package/dist/tools/structured.js

@@ -0,0 +1,247 @@
+/**
+ * Structured Output Tool - Get JSON responses with schema validation
+ *
+ * This tool enables Gemini to generate responses that adhere to a provided JSON Schema.
+ * Useful for:
+ * - Data extraction from unstructured text
+ * - Structured classification
+ * - Generating data for APIs or databases
+ *
+ * Supports combining with Google Search for grounded structured data.
+ */
+import { z } from 'zod';
+import { GoogleGenAI } from '@google/genai';
+import { logger } from '../utils/logger.js';
+/**
+ * Register structured output tools with the MCP server
+ */
+export function registerStructuredTool(server) {
+    server.tool('gemini-structured', {
+        prompt: z
+            .string()
+            .describe('The prompt or data to process'),
+        schema: z
+            .string()
+            .describe('JSON Schema as a string. Example: {"type":"object","properties":{"name":{"type":"string"},"age":{"type":"integer"}},"required":["name"]}'),
+        useGoogleSearch: z
+            .boolean()
+            .default(false)
+            .describe('Use Google Search to ground the response in real-world data'),
+    }, async ({ prompt, schema, useGoogleSearch }) => {
+        logger.info(`Structured output request: ${prompt.substring(0, 50)}...`);
+        try {
+            const apiKey = process.env.GEMINI_API_KEY;
+            if (!apiKey) {
+                throw new Error('GEMINI_API_KEY not set');
+            }
+            // Parse the schema
+            let jsonSchema;
+            try {
+                jsonSchema = JSON.parse(schema);
+            }
+            catch {
+                throw new Error('Invalid JSON schema provided. Please provide a valid JSON Schema string.');
+            }
+            const genAI = new GoogleGenAI({ apiKey });
+            const model = process.env.GEMINI_PRO_MODEL || 'gemini-3-pro-preview';
+            // Build config
+            const config = {
+                responseMimeType: 'application/json',
+                responseJsonSchema: jsonSchema,
+            };
+            // Add Google Search if requested
+            if (useGoogleSearch) {
+                config.tools = [{ googleSearch: {} }];
+            }
+            // Execute
+            const response = await genAI.models.generateContent({
+                model,
+                contents: prompt,
+                config,
+            });
+            const responseText = response.text || '';
+            // Validate that we got valid JSON
+            let parsedResponse;
+            try {
+                parsedResponse = JSON.parse(responseText);
+            }
+            catch {
+                throw new Error('Response was not valid JSON');
+            }
+            // Format nicely for display
+            const formattedJson = JSON.stringify(parsedResponse, null, 2);
+            logger.info('Structured output completed successfully');
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `**Structured Response:**\n\`\`\`json\n${formattedJson}\n\`\`\``,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error(`Error in structured output: ${errorMessage}`);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error generating structured output: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Convenience tool for common extraction patterns
+    server.tool('gemini-extract', {
+        text: z.string().describe('The text to extract information from'),
+        extractType: z
+            .enum(['entities', 'facts', 'summary', 'keywords', 'sentiment', 'custom'])
+            .describe('What type of information to extract'),
+        customFields: z
+            .string()
+            .optional()
+            .describe('For custom extraction: comma-separated list of fields to extract. Example: "name, date, amount, description"'),
+    }, async ({ text, extractType, customFields }) => {
+        logger.info(`Extraction request: ${extractType}`);
+        try {
+            const apiKey = process.env.GEMINI_API_KEY;
+            if (!apiKey) {
+                throw new Error('GEMINI_API_KEY not set');
+            }
+            const genAI = new GoogleGenAI({ apiKey });
+            const model = process.env.GEMINI_FLASH_MODEL || 'gemini-3-flash-preview';
+            // Build schema based on extraction type
+            let schema;
+            let prompt;
+            switch (extractType) {
+                case 'entities':
+                    schema = {
+                        type: 'object',
+                        properties: {
+                            people: { type: 'array', items: { type: 'string' }, description: 'Names of people mentioned' },
+                            organizations: { type: 'array', items: { type: 'string' }, description: 'Organizations mentioned' },
+                            locations: { type: 'array', items: { type: 'string' }, description: 'Locations mentioned' },
+                            dates: { type: 'array', items: { type: 'string' }, description: 'Dates mentioned' },
+                            amounts: { type: 'array', items: { type: 'string' }, description: 'Monetary amounts or quantities' },
+                        },
+                        required: ['people', 'organizations', 'locations', 'dates', 'amounts'],
+                    };
+                    prompt = `Extract all named entities from the following text:\n\n${text}`;
+                    break;
+                case 'facts':
+                    schema = {
+                        type: 'object',
+                        properties: {
+                            facts: {
+                                type: 'array',
+                                items: {
+                                    type: 'object',
+                                    properties: {
+                                        fact: { type: 'string', description: 'A factual statement' },
+                                        confidence: { type: 'string', enum: ['high', 'medium', 'low'] },
+                                    },
+                                    required: ['fact', 'confidence'],
+                                },
+                            },
+                        },
+                        required: ['facts'],
+                    };
+                    prompt = `Extract all factual statements from the following text:\n\n${text}`;
+                    break;
+                case 'summary':
+                    schema = {
+                        type: 'object',
+                        properties: {
+                            title: { type: 'string', description: 'A brief title' },
+                            summary: { type: 'string', description: 'A concise summary' },
+                            keyPoints: { type: 'array', items: { type: 'string' }, description: 'Key points' },
+                            topics: { type: 'array', items: { type: 'string' }, description: 'Main topics covered' },
+                        },
+                        required: ['title', 'summary', 'keyPoints', 'topics'],
+                    };
+                    prompt = `Summarize the following text and extract key information:\n\n${text}`;
+                    break;
+                case 'keywords':
+                    schema = {
+                        type: 'object',
+                        properties: {
+                            keywords: { type: 'array', items: { type: 'string' }, description: 'Important keywords' },
+                            phrases: { type: 'array', items: { type: 'string' }, description: 'Important phrases' },
+                            categories: { type: 'array', items: { type: 'string' }, description: 'Topic categories' },
+                        },
+                        required: ['keywords', 'phrases', 'categories'],
+                    };
+                    prompt = `Extract keywords, important phrases, and topic categories from the following text:\n\n${text}`;
+                    break;
+                case 'sentiment':
+                    schema = {
+                        type: 'object',
+                        properties: {
+                            overallSentiment: { type: 'string', enum: ['positive', 'negative', 'neutral', 'mixed'] },
+                            sentimentScore: { type: 'number', description: 'Score from -1 (negative) to 1 (positive)' },
+                            emotions: { type: 'array', items: { type: 'string' }, description: 'Emotions detected' },
+                            reasoning: { type: 'string', description: 'Brief explanation of the sentiment analysis' },
+                        },
+                        required: ['overallSentiment', 'sentimentScore', 'emotions', 'reasoning'],
+                    };
+                    prompt = `Analyze the sentiment of the following text:\n\n${text}`;
+                    break;
+                case 'custom':
+                    if (!customFields) {
+                        throw new Error('customFields is required for custom extraction');
+                    }
+                    const fields = customFields.split(',').map((f) => f.trim());
+                    const properties = {};
+                    for (const field of fields) {
+                        properties[field] = { type: 'string', description: `The ${field} extracted from the text` };
+                    }
+                    schema = {
+                        type: 'object',
+                        properties,
+                        required: fields,
+                    };
+                    prompt = `Extract the following information from the text: ${customFields}\n\nText:\n${text}`;
+                    break;
+                default:
+                    throw new Error(`Unknown extraction type: ${extractType}`);
+            }
+            // Execute
+            const response = await genAI.models.generateContent({
+                model,
+                contents: prompt,
+                config: {
+                    responseMimeType: 'application/json',
+                    responseJsonSchema: schema,
+                },
+            });
+            const responseText = response.text || '';
+            const parsedResponse = JSON.parse(responseText);
+            const formattedJson = JSON.stringify(parsedResponse, null, 2);
+            logger.info('Extraction completed successfully');
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `**Extracted ${extractType}:**\n\`\`\`json\n${formattedJson}\n\`\`\``,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error(`Error in extraction: ${errorMessage}`);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error extracting data: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/summarize.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Summarize Tool - Provides content summarization using Gemini models
+ *
+ * This tool allows summarizing long text content at different levels of detail.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/**
+ * Register summarization tools with the MCP server
+ */
+export declare function registerSummarizeTool(server: McpServer): void;

package/dist/tools/summarize.js

@@ -0,0 +1,77 @@
+/**
+ * Summarize Tool - Provides content summarization using Gemini models
+ *
+ * This tool allows summarizing long text content at different levels of detail.
+ */
+import { z } from "zod";
+import { generateWithGeminiFlash } from "../gemini-client.js";
+/**
+ * Register summarization tools with the MCP server
+ */
+export function registerSummarizeTool(server) {
+    server.tool("gemini-summarize", {
+        content: z.string().describe("The content to summarize"),
+        length: z.enum(["brief", "moderate", "detailed"]).default("moderate").describe("The desired summary length"),
+        format: z.enum(["paragraph", "bullet-points", "outline"]).default("paragraph").describe("The output format")
+    }, async ({ content, length, format }) => {
+        console.log(`Summarizing content (${length}, ${format})`);
+        try {
+            // Configure length parameters
+            let wordCount;
+            switch (length) {
+                case "brief":
+                    wordCount = "50-100 words";
+                    break;
+                case "moderate":
+                    wordCount = "150-250 words";
+                    break;
+                case "detailed":
+                    wordCount = "300-500 words";
+                    break;
+                default:
+                    wordCount = "150-250 words";
+            }
+            // Configure format instructions
+            let formatInstructions;
+            switch (format) {
+                case "bullet-points":
+                    formatInstructions = "Use bullet points for each key idea or concept.";
+                    break;
+                case "outline":
+                    formatInstructions = "Create a structured outline with main points and sub-points.";
+                    break;
+                case "paragraph":
+                default:
+                    formatInstructions = "Use cohesive paragraphs with clear transitions.";
+            }
+            const prompt = `
+Summarize the following content in ${wordCount}. ${formatInstructions}
+
+Focus on capturing the most important information, main arguments, and key conclusions.
+
+Content to summarize:
+"""
+${content}
+"""
+`;
+            const response = await generateWithGeminiFlash(prompt);
+            return {
+                content: [{
+                        type: "text",
+                        text: response
+                    }]
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`Error summarizing content: ${errorMessage}`);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error: ${errorMessage}`
+                    }],
+                isError: true
+            };
+        }
+    });
+}