Upd gemini mcp server script

README.md

@@ -91,7 +91,7 @@ tags:
 - **RAG Framework**: LlamaIndex with hierarchical node parsing
 - **Web Search**: Model Context Protocol (MCP) tools with automatic fallback to DuckDuckGo
 - **MCP Client**: Python MCP SDK for standardized tool integration
-- **Gemini MCP Server**: aistudio-mcp-server via MCP protocol
+- **Gemini MCP Server**: mcp-server via MCP protocol
 
 ## 📋 Requirements
 
@@ -112,7 +112,7 @@ export GEMINI_API_KEY="your-gemini-api-key"
 
 # Gemini MCP Server Configuration
 export MCP_SERVER_COMMAND="python"
-export MCP_SERVER_ARGS="-m aistudio_mcp_server"
+export MCP_SERVER_ARGS="-m mcp_server"
 
 # Optional Gemini Configuration
 export GEMINI_MODEL="gemini-2.5-flash"  # For harder tasks (default)
@@ -146,7 +146,7 @@ export GEMINI_TEMPERATURE=0.2  # Temperature for generation 0-2 (default: 0.2)
 2. **Install Gemini MCP Server**:
    ```bash
    # Install Python package
-   pip install aistudio-mcp-server
+   pip install mcp-server
    ```
 
 3. **Get Gemini API Key**:
@@ -157,7 +157,7 @@ export GEMINI_TEMPERATURE=0.2  # Temperature for generation 0-2 (default: 0.2)
    ```bash
    export GEMINI_API_KEY="your-gemini-api-key"
    export MCP_SERVER_COMMAND="python"
-   export MCP_SERVER_ARGS="-m aistudio_mcp_server"
+   export MCP_SERVER_ARGS="-m mcp_server"
    ```
 
 **Note**: The application requires Gemini MCP for translation, document parsing, transcription, and summarization. Web search functionality still supports fallback to direct library calls if MCP is not configured.

app.py

@@ -200,20 +200,18 @@ global_mcp_session = None
 global_mcp_stdio_ctx = None  # Store stdio context to keep it alive
 global_mcp_lock = threading.Lock()  # Lock for thread-safe session access
 # MCP server configuration via environment variables
-# Gemini MCP server options:
-# 1. Node.js version (recommended): npx @rlabs/gemini-mcp
-# 2. Python version: If you have a Python Gemini MCP server package installed
+# Gemini MCP server: Python-based server (gemini_mcp_server.py)
+# This works on Hugging Face Spaces without requiring npm/Node.js
 # Make sure GEMINI_API_KEY is set in environment variables
 # 
-# To use Node.js version (default):
-#   export MCP_SERVER_COMMAND="npx"
-#   export MCP_SERVER_ARGS="@rlabs/gemini-mcp"
-#
-# To use Python version (if available):
+# Default configuration uses the bundled gemini_mcp_server.py script
+# To override:
 #   export MCP_SERVER_COMMAND="python"
-#   export MCP_SERVER_ARGS="-m your_gemini_mcp_package"
-MCP_SERVER_COMMAND = os.environ.get("MCP_SERVER_COMMAND", "npx")
-MCP_SERVER_ARGS = os.environ.get("MCP_SERVER_ARGS", "@rlabs/gemini-mcp").split() if os.environ.get("MCP_SERVER_ARGS") else ["@rlabs/gemini-mcp"]
+#   export MCP_SERVER_ARGS="/path/to/gemini_mcp_server.py"
+script_dir = os.path.dirname(os.path.abspath(__file__))
+gemini_mcp_server_path = os.path.join(script_dir, "gemini_mcp_server.py")
+MCP_SERVER_COMMAND = os.environ.get("MCP_SERVER_COMMAND", "python")
+MCP_SERVER_ARGS = os.environ.get("MCP_SERVER_ARGS", gemini_mcp_server_path).split() if os.environ.get("MCP_SERVER_ARGS") else [gemini_mcp_server_path]
 
 async def get_mcp_session():
     """Get or create MCP client session with proper context management"""

gemini_mcp.py

@@ -0,0 +1,264 @@
+#!/usr/bin/env python3
+"""
+Gemini MCP Server
+A Python-based MCP server that provides Gemini AI capabilities via Model Context Protocol.
+This server implements the generate_content tool for translation, summarization, document parsing, and transcription.
+"""
+
+import os
+import sys
+import json
+import base64
+import asyncio
+import logging
+from typing import Any, Sequence
+from pathlib import Path
+
+# MCP imports
+try:
+    from mcp.server import Server
+    from mcp.types import Tool, TextContent, ImageContent, EmbeddedResource
+except ImportError:
+    print("Error: MCP SDK not installed. Install with: pip install mcp", file=sys.stderr)
+    sys.exit(1)
+
+# Gemini imports
+try:
+    import google.generativeai as genai
+except ImportError:
+    print("Error: google-generativeai not installed. Install with: pip install google-generativeai", file=sys.stderr)
+    sys.exit(1)
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Initialize Gemini
+GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY")
+if not GEMINI_API_KEY:
+    logger.error("GEMINI_API_KEY not set in environment variables")
+    sys.exit(1)
+
+genai.configure(api_key=GEMINI_API_KEY)
+
+# Configuration from environment
+GEMINI_MODEL = os.environ.get("GEMINI_MODEL", "gemini-2.5-flash")
+GEMINI_MODEL_LITE = os.environ.get("GEMINI_MODEL_LITE", "gemini-2.5-flash-lite")
+GEMINI_TIMEOUT = int(os.environ.get("GEMINI_TIMEOUT", "300000"))  # milliseconds
+GEMINI_MAX_OUTPUT_TOKENS = int(os.environ.get("GEMINI_MAX_OUTPUT_TOKENS", "8192"))
+GEMINI_MAX_FILES = int(os.environ.get("GEMINI_MAX_FILES", "10"))
+GEMINI_MAX_TOTAL_FILE_SIZE = int(os.environ.get("GEMINI_MAX_TOTAL_FILE_SIZE", "50"))  # MB
+GEMINI_TEMPERATURE = float(os.environ.get("GEMINI_TEMPERATURE", "0.2"))
+
+# Create MCP server
+app = Server("gemini-mcp-server")
+
+def decode_base64_file(content: str, mime_type: str = None) -> bytes:
+    """Decode base64 encoded file content"""
+    try:
+        return base64.b64decode(content)
+    except Exception as e:
+        logger.error(f"Error decoding base64 content: {e}")
+        raise
+
+def prepare_gemini_files(files: list) -> list:
+    """Prepare files for Gemini API"""
+    gemini_parts = []
+    
+    for file_obj in files:
+        try:
+            # Handle file with path
+            if "path" in file_obj:
+                file_path = file_obj["path"]
+                mime_type = file_obj.get("type")
+                
+                if not os.path.exists(file_path):
+                    logger.warning(f"File not found: {file_path}")
+                    continue
+                
+                # Read file
+                with open(file_path, 'rb') as f:
+                    file_data = f.read()
+                
+                # Auto-detect MIME type if not provided
+                if not mime_type:
+                    from mimetypes import guess_type
+                    mime_type, _ = guess_type(file_path)
+                    if not mime_type:
+                        mime_type = "application/octet-stream"
+            
+            # Handle file with base64 content
+            elif "content" in file_obj:
+                file_data = decode_base64_file(file_obj["content"])
+                mime_type = file_obj.get("type", "application/octet-stream")
+            else:
+                logger.warning("File object must have either 'path' or 'content'")
+                continue
+            
+            # Add to Gemini parts
+            gemini_parts.append({
+                "mime_type": mime_type,
+                "data": file_data
+            })
+            
+        except Exception as e:
+            logger.error(f"Error processing file: {e}")
+            continue
+    
+    return gemini_parts
+
+@app.list_tools()
+async def list_tools() -> list[Tool]:
+    """List available tools"""
+    return [
+        Tool(
+            name="generate_content",
+            description="Generate content using Gemini AI. Supports text generation, translation, summarization, document parsing, and audio transcription.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "user_prompt": {
+                        "type": "string",
+                        "description": "User prompt for generation (required)"
+                    },
+                    "system_prompt": {
+                        "type": "string",
+                        "description": "System prompt to guide AI behavior (optional)"
+                    },
+                    "files": {
+                        "type": "array",
+                        "description": "Array of files to include in generation (optional)",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "path": {"type": "string", "description": "Path to file"},
+                                "content": {"type": "string", "description": "Base64 encoded file content"},
+                                "type": {"type": "string", "description": "MIME type (auto-detected from file extension)"}
+                            }
+                        }
+                    },
+                    "model": {
+                        "type": "string",
+                        "description": f"Gemini model to use (default: {GEMINI_MODEL})"
+                    },
+                    "temperature": {
+                        "type": "number",
+                        "description": f"Temperature for generation 0-2 (default: {GEMINI_TEMPERATURE})"
+                    }
+                },
+                "required": ["user_prompt"]
+            }
+        )
+    ]
+
+@app.call_tool()
+async def call_tool(name: str, arguments: dict) -> Sequence[TextContent | ImageContent | EmbeddedResource]:
+    """Handle tool calls"""
+    if name == "generate_content":
+        try:
+            user_prompt = arguments.get("user_prompt")
+            if not user_prompt:
+                return [TextContent(type="text", text="Error: user_prompt is required")]
+            
+            system_prompt = arguments.get("system_prompt")
+            files = arguments.get("files", [])
+            model = arguments.get("model", GEMINI_MODEL)
+            temperature = float(arguments.get("temperature", GEMINI_TEMPERATURE))
+            
+            # Prepare model
+            try:
+                gemini_model = genai.GenerativeModel(model)
+            except Exception as e:
+                logger.error(f"Error loading model {model}: {e}")
+                return [TextContent(type="text", text=f"Error: Failed to load model {model}")]
+            
+            # Prepare content parts
+            parts = []
+            
+            # Add system instruction if provided
+            if system_prompt:
+                # Gemini models use system_instruction parameter
+                generation_config = genai.types.GenerationConfig(
+                    temperature=temperature,
+                    max_output_tokens=GEMINI_MAX_OUTPUT_TOKENS
+                )
+            else:
+                generation_config = genai.types.GenerationConfig(
+                    temperature=temperature,
+                    max_output_tokens=GEMINI_MAX_OUTPUT_TOKENS
+                )
+            
+            # Prepare content parts for Gemini
+            # Gemini API accepts a list where each part can be:
+            # - A string (for text)
+            # - A dict with "mime_type" and "data" keys (for binary data)
+            content_parts = []
+            
+            # Prepare files if provided
+            if files:
+                gemini_files = prepare_gemini_files(files)
+                for file_part in gemini_files:
+                    # Use genai.types.Part or dict format
+                    content_parts.append({
+                        "mime_type": file_part["mime_type"],
+                        "data": file_part["data"]
+                    })
+            
+            # Add text prompt (as string)
+            content_parts.append(user_prompt)
+            
+            # Generate content
+            try:
+                if system_prompt:
+                    # Use system_instruction for models that support it
+                    response = await asyncio.to_thread(
+                        gemini_model.generate_content,
+                        content_parts,
+                        generation_config=generation_config,
+                        system_instruction=system_prompt
+                    )
+                else:
+                    response = await asyncio.to_thread(
+                        gemini_model.generate_content,
+                        content_parts,
+                        generation_config=generation_config
+                    )
+                
+                # Extract text from response
+                if response and response.text:
+                    return [TextContent(type="text", text=response.text)]
+                else:
+                    return [TextContent(type="text", text="Error: No response from Gemini")]
+                    
+            except Exception as e:
+                logger.error(f"Error generating content: {e}")
+                return [TextContent(type="text", text=f"Error: {str(e)}")]
+                
+        except Exception as e:
+            logger.error(f"Error in generate_content: {e}")
+            import traceback
+            logger.debug(traceback.format_exc())
+            return [TextContent(type="text", text=f"Error: {str(e)}")]
+    else:
+        return [TextContent(type="text", text=f"Unknown tool: {name}")]
+
+async def main():
+    """Main entry point"""
+    logger.info("Starting Gemini MCP Server...")
+    logger.info(f"Gemini API Key: {'Set' if GEMINI_API_KEY else 'Not Set'}")
+    logger.info(f"Default Model: {GEMINI_MODEL}")
+    logger.info(f"Default Lite Model: {GEMINI_MODEL_LITE}")
+    
+    # Use stdio_server from mcp.server.stdio
+    from mcp.server.stdio import stdio_server
+    
+    async with stdio_server() as streams:
+        await app.run(
+            streams[0],  # read_stream
+            streams[1],  # write_stream
+            app.create_initialization_options()
+        )
+
+if __name__ == "__main__":
+    asyncio.run(main())
+

requirements.txt

@@ -15,7 +15,7 @@ gradio
 # MCP dependencies (required for Gemini MCP)
 mcp
 nest-asyncio
-mcp-server
+google-generativeai
 # Fallback dependencies (used if MCP is not available)
 requests
 beautifulsoup4