@rlabs-inc/gemini-mcp 0.5.0

package/dist/tools/url-context.d.ts

@@ -0,0 +1,17 @@
+/**
+ * URL Context Tool - Analyze web pages by URL
+ *
+ * The URL context tool lets you provide URLs for Gemini to analyze.
+ * Useful for:
+ * - Extract data from web pages (prices, names, key findings)
+ * - Compare documents from multiple URLs
+ * - Synthesize content from several sources
+ * - Analyze code from GitHub or documentation sites
+ *
+ * Can be combined with Google Search for powerful workflows.
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Register URL context tools with the MCP server
+ */
+export declare function registerUrlContextTool(server: McpServer): void;

package/dist/tools/url-context.js

@@ -0,0 +1,226 @@
+/**
+ * URL Context Tool - Analyze web pages by URL
+ *
+ * The URL context tool lets you provide URLs for Gemini to analyze.
+ * Useful for:
+ * - Extract data from web pages (prices, names, key findings)
+ * - Compare documents from multiple URLs
+ * - Synthesize content from several sources
+ * - Analyze code from GitHub or documentation sites
+ *
+ * Can be combined with Google Search for powerful workflows.
+ */
+import { z } from 'zod';
+import { GoogleGenAI } from '@google/genai';
+import { logger } from '../utils/logger.js';
+/**
+ * Register URL context tools with the MCP server
+ */
+export function registerUrlContextTool(server) {
+    server.tool('gemini-analyze-url', {
+        urls: z
+            .array(z.string())
+            .min(1)
+            .max(20)
+            .describe('URLs to analyze (1-20 URLs)'),
+        question: z
+            .string()
+            .describe('Question about the URLs or task to perform'),
+        useGoogleSearch: z
+            .boolean()
+            .default(false)
+            .describe('Also use Google Search to find additional context'),
+    }, async ({ urls, question, useGoogleSearch }) => {
+        logger.info(`URL context analysis: ${urls.length} URLs`);
+        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_PRO_MODEL || 'gemini-3-pro-preview';
+            // Build the prompt with URLs
+            const urlList = urls.map((url, i) => `${i + 1}. ${url}`).join('\n');
+            const prompt = `${question}\n\nURLs to analyze:\n${urlList}`;
+            // Build tools config
+            const tools = [{ urlContext: {} }];
+            if (useGoogleSearch) {
+                tools.push({ googleSearch: {} });
+            }
+            // Execute
+            const response = await genAI.models.generateContent({
+                model,
+                contents: prompt,
+                config: {
+                    tools,
+                },
+            });
+            const candidate = response.candidates?.[0];
+            if (!candidate) {
+                throw new Error('No response from URL analysis');
+            }
+            let responseText = response.text || '';
+            // Add URL retrieval status if available
+            const urlContextMetadata = candidate.urlContextMetadata;
+            if (urlContextMetadata?.urlMetadata) {
+                responseText += '\n\n---\n**URL Retrieval Status:**\n';
+                for (const meta of urlContextMetadata.urlMetadata) {
+                    const status = meta.urlRetrievalStatus === 'URL_RETRIEVAL_STATUS_SUCCESS'
+                        ? '✓'
+                        : '✗';
+                    responseText += `${status} ${meta.retrievedUrl}\n`;
+                }
+            }
+            logger.info('URL context analysis completed');
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: responseText,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error(`Error in URL analysis: ${errorMessage}`);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error analyzing URLs: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Convenience tool for comparing content from multiple URLs
+    server.tool('gemini-compare-urls', {
+        url1: z.string().describe('First URL to compare'),
+        url2: z.string().describe('Second URL to compare'),
+        aspect: z
+            .string()
+            .optional()
+            .describe('Specific aspect to compare (e.g., "pricing", "features", "ingredients")'),
+    }, async ({ url1, url2, aspect }) => {
+        logger.info(`URL comparison: ${url1} vs ${url2}`);
+        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';
+            const prompt = aspect
+                ? `Compare the ${aspect} from these two URLs:\n1. ${url1}\n2. ${url2}\n\nProvide a detailed comparison highlighting differences and similarities.`
+                : `Compare the content from these two URLs:\n1. ${url1}\n2. ${url2}\n\nProvide a comprehensive comparison of key information from both sources.`;
+            const response = await genAI.models.generateContent({
+                model,
+                contents: prompt,
+                config: {
+                    tools: [{ urlContext: {} }],
+                },
+            });
+            logger.info('URL comparison completed');
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: response.text || 'Unable to compare URLs.',
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error(`Error in URL comparison: ${errorMessage}`);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error comparing URLs: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Tool for extracting specific data from URLs
+    server.tool('gemini-extract-from-url', {
+        url: z.string().describe('URL to extract data from'),
+        dataType: z
+            .enum(['prices', 'contacts', 'dates', 'products', 'links', 'custom'])
+            .describe('Type of data to extract'),
+        customFields: z
+            .string()
+            .optional()
+            .describe('For custom extraction: comma-separated fields to extract'),
+    }, async ({ url, dataType, customFields }) => {
+        logger.info(`URL extraction: ${dataType} from ${url}`);
+        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 prompt based on data type
+            let prompt;
+            switch (dataType) {
+                case 'prices':
+                    prompt = `Extract all prices and pricing information from this URL: ${url}\n\nReturn as a structured list with item name and price.`;
+                    break;
+                case 'contacts':
+                    prompt = `Extract all contact information (emails, phone numbers, addresses, social media) from this URL: ${url}`;
+                    break;
+                case 'dates':
+                    prompt = `Extract all dates, times, and scheduling information from this URL: ${url}`;
+                    break;
+                case 'products':
+                    prompt = `Extract all product names, descriptions, and details from this URL: ${url}`;
+                    break;
+                case 'links':
+                    prompt = `Extract all important links from this URL: ${url}\n\nCategorize them by purpose.`;
+                    break;
+                case 'custom':
+                    if (!customFields) {
+                        throw new Error('customFields required for custom extraction');
+                    }
+                    prompt = `Extract the following information from this URL: ${url}\n\nFields to extract: ${customFields}`;
+                    break;
+                default:
+                    prompt = `Extract key information from this URL: ${url}`;
+            }
+            const response = await genAI.models.generateContent({
+                model,
+                contents: prompt,
+                config: {
+                    tools: [{ urlContext: {} }],
+                },
+            });
+            logger.info('URL extraction completed');
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: response.text || 'No data extracted.',
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error(`Error in URL extraction: ${errorMessage}`);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error extracting from URL: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/video-gen.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Video Generation Tool - Generate videos using Gemini's Veo model
+ *
+ * This tool generates videos from text descriptions. Video generation is async,
+ * so we provide tools to start generation and check status.
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Register video generation tools with the MCP server
+ */
+export declare function registerVideoGenTool(server: McpServer): void;

package/dist/tools/video-gen.js

@@ -0,0 +1,136 @@
+/**
+ * Video Generation Tool - Generate videos using Gemini's Veo model
+ *
+ * This tool generates videos from text descriptions. Video generation is async,
+ * so we provide tools to start generation and check status.
+ */
+import { z } from 'zod';
+import { startVideoGeneration, checkVideoStatus, getOutputDir, } from '../gemini-client.js';
+import { logger } from '../utils/logger.js';
+/**
+ * Register video generation tools with the MCP server
+ */
+export function registerVideoGenTool(server) {
+    // Start video generation
+    server.tool('gemini-generate-video', {
+        prompt: z
+            .string()
+            .describe('Description of the video to generate (be detailed!)'),
+        aspectRatio: z
+            .enum(['16:9', '9:16'])
+            .default('16:9')
+            .describe('Aspect ratio (16:9 for landscape, 9:16 for portrait/mobile)'),
+        negativePrompt: z
+            .string()
+            .optional()
+            .describe('Things to avoid in the video (e.g., "text, watermarks, blurry")'),
+    }, async ({ prompt, aspectRatio, negativePrompt }) => {
+        logger.info(`Starting video generation: ${prompt.substring(0, 50)}...`);
+        try {
+            const result = await startVideoGeneration(prompt, {
+                aspectRatio,
+                negativePrompt,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Video generation started!
+
+**Operation ID:** \`${result.operationName}\`
+**Status:** ${result.status}
+
+Video generation takes 1-5 minutes. Use the \`gemini-check-video\` tool with the operation ID above to check progress and download when complete.
+
+**Tip:** Save the operation ID - you'll need it to check status and retrieve the video.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error(`Error starting video generation: ${errorMessage}`);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error starting video generation: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Check video generation status
+    server.tool('gemini-check-video', {
+        operationId: z
+            .string()
+            .describe('The operation ID returned when starting video generation'),
+    }, async ({ operationId }) => {
+        logger.info(`Checking video status: ${operationId}`);
+        try {
+            const result = await checkVideoStatus(operationId);
+            if (result.status === 'completed') {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Video generation complete!
+
+**Status:** ${result.status}
+${result.filePath ? `**Saved to:** ${result.filePath}` : ''}
+${result.videoUri ? `**Video URI:** ${result.videoUri}` : ''}
+**Output directory:** ${getOutputDir()}
+
+The video has been downloaded and saved to disk.`,
+                        },
+                    ],
+                };
+            }
+            else if (result.status === 'failed') {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Video generation failed.
+
+**Status:** ${result.status}
+**Error:** ${result.error || 'Unknown error'}
+
+Please try again with a different prompt.`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            else {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Video still generating...
+
+**Status:** ${result.status}
+**Operation ID:** ${result.operationName}
+
+Please check again in 30-60 seconds using the \`gemini-check-video\` tool.`,
+                        },
+                    ],
+                };
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error(`Error checking video status: ${errorMessage}`);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error checking video status: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/youtube.d.ts

@@ -0,0 +1,16 @@
+/**
+ * YouTube Analysis Tool - Analyze YouTube videos directly by URL
+ *
+ * Gemini can process YouTube videos natively, enabling:
+ * - Video summarization
+ * - Q&A about video content
+ * - Timestamp-based analysis
+ * - Audio and visual understanding
+ *
+ * Supports clipping intervals to analyze specific portions of videos.
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Register YouTube analysis tools with the MCP server
+ */
+export declare function registerYouTubeTool(server: McpServer): void;

package/dist/tools/youtube.js

@@ -0,0 +1,218 @@
+/**
+ * YouTube Analysis Tool - Analyze YouTube videos directly by URL
+ *
+ * Gemini can process YouTube videos natively, enabling:
+ * - Video summarization
+ * - Q&A about video content
+ * - Timestamp-based analysis
+ * - Audio and visual understanding
+ *
+ * Supports clipping intervals to analyze specific portions of videos.
+ */
+import { z } from 'zod';
+import { GoogleGenAI } from '@google/genai';
+import { logger } from '../utils/logger.js';
+/**
+ * Parse time string to seconds (supports formats like "1m30s", "90s", "1:30", "90")
+ */
+function parseTimeToSeconds(time) {
+    // Handle MM:SS format
+    if (time.includes(':')) {
+        const [mins, secs] = time.split(':').map(Number);
+        return `${mins * 60 + secs}s`;
+    }
+    // Handle XmYs format
+    const minMatch = time.match(/(\d+)m/);
+    const secMatch = time.match(/(\d+)s/);
+    const mins = minMatch ? parseInt(minMatch[1]) : 0;
+    const secs = secMatch ? parseInt(secMatch[1]) : 0;
+    if (mins > 0 || secMatch) {
+        return `${mins * 60 + secs}s`;
+    }
+    // Handle plain number (assume seconds)
+    const num = parseInt(time);
+    if (!isNaN(num)) {
+        return `${num}s`;
+    }
+    return time;
+}
+/**
+ * Register YouTube analysis tools with the MCP server
+ */
+export function registerYouTubeTool(server) {
+    server.tool('gemini-youtube', {
+        url: z
+            .string()
+            .describe('YouTube video URL (e.g., https://www.youtube.com/watch?v=...)'),
+        question: z
+            .string()
+            .describe('Question about the video or task to perform (e.g., "Summarize this video", "What happens at 2:30?")'),
+        startTime: z
+            .string()
+            .optional()
+            .describe('Start time for analysis (e.g., "1m30s", "90", "1:30"). Optional.'),
+        endTime: z
+            .string()
+            .optional()
+            .describe('End time for analysis (e.g., "5m00s", "300", "5:00"). Optional.'),
+    }, async ({ url, question, startTime, endTime }) => {
+        logger.info(`YouTube analysis: ${url.substring(0, 50)}...`);
+        try {
+            const apiKey = process.env.GEMINI_API_KEY;
+            if (!apiKey) {
+                throw new Error('GEMINI_API_KEY not set');
+            }
+            // Validate YouTube URL
+            if (!url.includes('youtube.com') && !url.includes('youtu.be')) {
+                throw new Error('Invalid YouTube URL. Please provide a valid YouTube video link.');
+            }
+            const genAI = new GoogleGenAI({ apiKey });
+            const model = process.env.GEMINI_PRO_MODEL || 'gemini-3-pro-preview';
+            // Build the video part with optional clipping
+            const videoPart = {
+                fileData: {
+                    fileUri: url,
+                    mimeType: 'video/*',
+                },
+            };
+            // Add video metadata for clipping if provided
+            if (startTime || endTime) {
+                const videoMetadata = {};
+                if (startTime) {
+                    videoMetadata.startOffset = parseTimeToSeconds(startTime);
+                }
+                if (endTime) {
+                    videoMetadata.endOffset = parseTimeToSeconds(endTime);
+                }
+                videoPart.videoMetadata = videoMetadata;
+            }
+            // Build contents
+            const contents = [
+                {
+                    role: 'user',
+                    parts: [videoPart, { text: question }],
+                },
+            ];
+            // Execute
+            const response = await genAI.models.generateContent({
+                model,
+                contents,
+            });
+            const responseText = response.text || '';
+            // Build response with context
+            let resultText = responseText;
+            if (startTime || endTime) {
+                const clipInfo = [];
+                if (startTime)
+                    clipInfo.push(`from ${startTime}`);
+                if (endTime)
+                    clipInfo.push(`to ${endTime}`);
+                resultText = `*Analyzed video clip ${clipInfo.join(' ')}*\n\n${responseText}`;
+            }
+            logger.info('YouTube analysis completed successfully');
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: resultText,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error(`Error in YouTube analysis: ${errorMessage}`);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error analyzing YouTube video: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Convenience tool for YouTube summarization
+    server.tool('gemini-youtube-summary', {
+        url: z.string().describe('YouTube video URL'),
+        style: z
+            .enum(['brief', 'detailed', 'bullet-points', 'chapters'])
+            .default('brief')
+            .describe('Summary style'),
+    }, async ({ url, style }) => {
+        logger.info(`YouTube summary: ${url.substring(0, 50)}...`);
+        try {
+            const apiKey = process.env.GEMINI_API_KEY;
+            if (!apiKey) {
+                throw new Error('GEMINI_API_KEY not set');
+            }
+            if (!url.includes('youtube.com') && !url.includes('youtu.be')) {
+                throw new Error('Invalid YouTube URL');
+            }
+            const genAI = new GoogleGenAI({ apiKey });
+            const model = process.env.GEMINI_FLASH_MODEL || 'gemini-3-flash-preview';
+            // Build prompt based on style
+            let prompt;
+            switch (style) {
+                case 'brief':
+                    prompt = 'Summarize this video in 2-3 sentences.';
+                    break;
+                case 'detailed':
+                    prompt =
+                        'Provide a detailed summary of this video, covering all main points and key takeaways. Include relevant timestamps for important moments.';
+                    break;
+                case 'bullet-points':
+                    prompt =
+                        'Summarize this video as a bullet-point list of key points and takeaways.';
+                    break;
+                case 'chapters':
+                    prompt =
+                        'Create a chapter breakdown of this video with timestamps and descriptions for each section.';
+                    break;
+                default:
+                    prompt = 'Summarize this video.';
+            }
+            const contents = [
+                {
+                    role: 'user',
+                    parts: [
+                        {
+                            fileData: {
+                                fileUri: url,
+                                mimeType: 'video/*',
+                            },
+                        },
+                        { text: prompt },
+                    ],
+                },
+            ];
+            const response = await genAI.models.generateContent({
+                model,
+                contents,
+            });
+            logger.info('YouTube summary completed successfully');
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: response.text || 'Unable to generate summary.',
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error(`Error in YouTube summary: ${errorMessage}`);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error summarizing YouTube video: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/utils/logger.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Logger Utility - Provides logging capabilities with different verbosity levels
+ */
+export type LogLevel = "quiet" | "normal" | "verbose";
+interface Logger {
+    error: (message: string, ...args: any[]) => void;
+    warn: (message: string, ...args: any[]) => void;
+    info: (message: string, ...args: any[]) => void;
+    debug: (message: string, ...args: any[]) => void;
+    prompt: (prompt: string) => void;
+    response: (response: string) => void;
+}
+/**
+ * Sets up the logger with the specified verbosity level
+ */
+export declare function setupLogger(level: LogLevel): void;
+/**
+ * Returns whether full prompts and responses should be logged
+ */
+export declare function shouldLogFullMessages(): boolean;
+/**
+ * Returns whether info messages should be logged
+ */
+export declare function shouldLogInfo(): boolean;
+/**
+ * Returns whether debug messages should be logged
+ */
+export declare function shouldLogDebug(): boolean;
+/**
+ * The logger instance
+ */
+export declare const logger: Logger;
+export {};