adding MCPs for gemini

Author: cmungall

README.md

@@ -23,6 +23,10 @@ Available coders:
 metacoder "Write a Python function to calculate fibonacci numbers" -c claude -w my-scripts/
 ...
 
+# With custom instructions
+metacoder "Refactor this code" -c claude --instructions coding_guidelines.md
+...
+
 # Using MCPs
 metacoder "Fix issue 1234" -w path/to/my-repo --mcp-collection github_mcps.yaml
 ...

docs/configuration.md

@@ -47,6 +47,43 @@ For detailed information about MCP configuration and usage, see the [MCP Support
 metacoder "Your prompt" --config myconfig.yaml
 ```
 
+## Custom Instructions
+
+You can provide custom instructions to any coder using the `--instructions` option:
+
+```bash
+metacoder "Your prompt" --instructions custom_instructions.md
+```
+
+The instructions file is loaded and passed to the coder's instruction handling mechanism. Each coder will use these instructions according to its own configuration:
+
+- **Claude**: Instructions are written to `CLAUDE.md`
+- **Goose**: Instructions are written to `.goosehints`
+- **Gemini**: Instructions are written to `GEMINI.md`
+- **Other coders**: Check the specific coder documentation
+
+Example instructions file:
+
+```markdown
+# Custom Instructions
+
+You are an expert Python developer following these guidelines:
+1. Use type hints for all functions
+2. Write comprehensive docstrings
+3. Follow PEP 8 style guidelines
+4. Include unit tests for all new functions
+```
+
+You can combine instructions with other configuration options:
+
+```bash
+metacoder "Refactor this code" \
+  --coder claude \
+  --instructions style_guide.md \
+  --config claude_config.yaml \
+  --mcp-collection tools.yaml
+```
+
 ## Environment Variables
 
 Config files support environment variable expansion:

docs/getting-started.md

@@ -51,6 +51,9 @@ metacoder "Analyze this project" --workdir ./myproject
 # Use configuration file
 metacoder "Build feature X" --config config.yaml
 
+# Use custom instructions file
+metacoder "Review code" --instructions guidelines.md
+
 # Use MCP extensions
 metacoder "Search for papers on LLMs" --mcp-collection research_mcps.yaml
 ```

docs/index.md

@@ -23,6 +23,10 @@ Available coders:
 metacoder "Write a Python function to calculate fibonacci numbers" -c claude -w my-scripts/
 ...
 
+# With custom instructions
+metacoder "Refactor this code" -c claude --instructions coding_guidelines.md
+...
+
 # Using MCPs
 metacoder "Fix issue 1234" -w path/to/my-repo --mcp-collection github_mcps.yaml
 ...
@@ -57,6 +61,7 @@ Mungall, C. (2025, May 28). How to make your KG interoperable: Ontologies and Se
 
 - Unified CLI for all supported coders
 - Consistent [configuration](configuration.md) format (YAML-based)
+- Custom instructions support via `--instructions` flag
 - Unified [MCP configuration](mcps.md)
 - Standardized working directory management
 

src/metacoder/coders/dummy.py

@@ -1,4 +1,6 @@
+from pathlib import Path
 from metacoder.coders.base_coder import BaseCoder, CoderConfigObject, CoderOutput, ToolUse
+from metacoder.configuration import ConfigFileRole
 
 
 class DummyCoder(BaseCoder):
@@ -18,14 +20,34 @@ def supports_mcp(cls) -> bool:
         """DummyCoder supports MCP for testing purposes."""
         return True
 
+    @classmethod
+    def default_config_paths(cls) -> dict[Path, ConfigFileRole]:
+        return {
+            Path("INSTRUCTIONS.md"): ConfigFileRole.PRIMARY_INSTRUCTION,
+        }
+
     def default_config_objects(self) -> list[CoderConfigObject]:
         return []
 
     def run(self, input_text: str) -> CoderOutput:
+        # Check if instructions were set
+        instructions_content = None
+        if self.config_objects:
+            for obj in self.config_objects:
+                if obj.relative_path == "INSTRUCTIONS.md" or obj.relative_path == str(Path("INSTRUCTIONS.md")):
+                    instructions_content = obj.content
+                    break
+        
+        # Create response based on whether instructions exist
+        if instructions_content:
+            response = f"Instructions loaded: {instructions_content}\nProcessing: {input_text}"
+        else:
+            response = f"you said: {input_text}"
+            
         output = CoderOutput(
-            stdout="you said: " + input_text,
+            stdout=response,
             stderr="",
-            result_text="you said: " + input_text,
+            result_text=response,
         )
 
         # Add fake tool uses if input mentions tools, MCP, or specific services

src/metacoder/coders/gemini.py

@@ -4,6 +4,7 @@
 import logging
 import shutil
 import re
+from typing import Any
 
 from metacoder.coders.base_coder import (
     BaseCoder,
@@ -12,6 +13,7 @@
     FileType,
     change_directory,
 )
+from metacoder.configuration import ConfigFileRole, MCPConfig, MCPType
 
 
 logger = logging.getLogger(__name__)
@@ -21,23 +23,106 @@ class GeminiCoder(BaseCoder):
     """
     Google Gemini AI assistant integration.
 
-    Note: Requires gemini CLI to be installed.
+    Gemini-specific configuration:
+
+    You can provide the following files in your configuration directory:
+
+    - `GEMINI.md` - Primary instructions for the assistant
+    - `.gemini/settings.json` - Configuration including MCP servers
+    - `.gemini/commands/` - Custom commands directory
+
+    MCP Support:
+    
+    Gemini CLI supports MCP (Model Context Protocol) servers through the
+    mcpServers configuration in .gemini/settings.json. When MCPs are configured
+    through Metacoder, they will be automatically added to the settings file.
+
+    The Gemini CLI expects MCP servers to be configured in the following format:
+    {
+        "mcpServers": {
+            "server_name": {
+                "command": "npx",
+                "args": ["-y", "@modelcontextprotocol/server-name"],
+                "env": {"API_KEY": "${API_KEY}"},
+                "timeout": 30000
+            }
+        }
+    }
+
+    Note: Requires gemini CLI to be installed (npm install -g @google/gemini-cli).
     """
 
     @classmethod
     def is_available(cls) -> bool:
         """Check if gemini command is available."""
         return shutil.which("gemini") is not None
 
+    @classmethod
+    def supports_mcp(cls) -> bool:
+        """GeminiCoder supports MCP extensions."""
+        return True
+
+    @classmethod
+    def default_config_paths(cls) -> dict[Path, ConfigFileRole]:
+        return {
+            Path("GEMINI.md"): ConfigFileRole.PRIMARY_INSTRUCTION,
+            Path(".gemini/settings.json"): ConfigFileRole.CONFIG,
+            Path(".gemini/commands"): ConfigFileRole.CONFIG,
+        }
+
+    def mcp_config_to_gemini_format(self, mcp: MCPConfig) -> dict[str, Any]:
+        """Convert MCPConfig to Gemini's MCP server format."""
+        server_config: dict[str, Any] = {}
+
+        # For stdio type MCPs
+        if mcp.type == MCPType.STDIO and mcp.command:
+            server_config["command"] = mcp.command
+            if mcp.args:
+                server_config["args"] = mcp.args
+            if mcp.env:
+                server_config["env"] = mcp.env
+            # Add optional timeout if needed
+            server_config["timeout"] = 30000  # 30 seconds default
+
+        # For HTTP type MCPs
+        elif mcp.type == MCPType.HTTP:
+            raise NotImplementedError(
+                "HTTP MCPs are not supported for Gemini CLI yet"
+            )
+
+        return server_config
+
     def default_config_objects(self) -> list[CoderConfigObject]:
-        """Default configuration for Gemini."""
-        return [
-            CoderConfigObject(
-                file_type=FileType.YAML,
-                relative_path=".codex/config.yaml",
-                content={"model": "gemini-2.5-pro", "provider": "google"},
+        """Generate config objects including MCP configuration."""
+        config_objects = []
+        
+        # Create .gemini/settings.json if we have MCP extensions
+        settings_content: dict[str, Any] = {}
+        
+        # Add MCP servers configuration if extensions are present
+        if self.config and self.config.extensions:
+            mcp_servers = {}
+            for mcp in self.config.extensions:
+                if mcp.enabled:
+                    mcp_servers[mcp.name] = self.mcp_config_to_gemini_format(mcp)
+            
+            if mcp_servers:
+                settings_content["mcpServers"] = mcp_servers
+        
+        # Add settings.json if we have content to write
+        if settings_content:
+            config_objects.append(
+                CoderConfigObject(
+                    file_type=FileType.JSON,
+                    relative_path=".gemini/settings.json",
+                    content=settings_content,
+                )
             )
-        ]
+        
+        # Add GEMINI.md if present in config
+        # This could contain instructions specific to the task
+        
+        return config_objects
 
     def run(self, input_text: str) -> CoderOutput:
         """
@@ -50,14 +135,15 @@ def run(self, input_text: str) -> CoderOutput:
             # Gemini expects HOME to be current directory for config
             env["HOME"] = "."
 
-            # Validate required files
-            if not Path("./.codex/config.yaml").exists():
-                raise ValueError("Codex config.yaml file not found")
-
             text = self.expand_prompt(input_text)
-            command = ["gemini", "-d", "-m", "gemini-2.5-pro", "-y", "-p", text]
-
-            logger.info(f"🤖 Running command: {' '.join(command)}")
+            
+            # Build the command
+            # The gemini CLI uses conversational interface, so we need to handle it differently
+            # For now, we'll use echo to pipe the prompt
+            command = ["sh", "-c", f'echo "{text}" | gemini']
+
+            logger.info("💎 Running command: gemini with prompt")
+            logger.debug(f"💎 Full command: {' '.join(command)}")
             start_time = time.time()
 
             try:
@@ -72,7 +158,7 @@ def run(self, input_text: str) -> CoderOutput:
                 )
 
             end_time = time.time()
-            print(f"🤖 Command took {end_time - start_time} seconds")
+            logger.info(f"💎 Command took {end_time - start_time} seconds")
 
             # Parse the output
             ao = CoderOutput(stdout=result.stdout, stderr=result.stderr)

src/metacoder/configuration.py

@@ -51,9 +51,10 @@ class AIModelProvider(BaseModel):
     An AI model provider is a provider of an AI model.
     """
 
-    name: str
-    api_key: str | None = None
-    metadata: dict[str, Any] = {}
+    name: str = Field(..., description="Name of the model provider")
+    api_key: str | None = Field(None, description="API key for the model provider")
+    metadata: dict[str, Any] = Field({}, description="Metadata for the model provider")
+    base_url: str | None = Field(None, description="Base URL for the model provider")
 
 
 class AIModelConfig(BaseModel):

src/metacoder/metacoder.py

@@ -243,6 +243,12 @@ def cli(ctx):
 )
 @click.option("--verbose", "-v", is_flag=True, help="Enable verbose logging")
 @click.option("--quiet", "-q", is_flag=True, help="Quiet mode")
+@click.option(
+    "--instructions",
+    "-i",
+    type=click.Path(exists=True),
+    help="Path to instructions file to load and pass to the coder",
+)
 def run(
     prompt: str,
     coder: str,
@@ -255,6 +261,7 @@ def run(
     model: Optional[str],
     verbose: bool,
     quiet: bool,
+    instructions: Optional[str],
 ):
     """
     Run a prompt with the specified coder.
@@ -271,6 +278,10 @@ def run(
     # Use specific coder with config
     metacoder run "Fix the bug in main.py" --coder goose --config goose_config.yaml
 
+    \b
+    # Use custom instructions from a file
+    metacoder run "Write tests" --coder claude --instructions instructions.md
+
     \b
     # Use MCP collection
     metacoder run "Search for papers on LLMs" --mcp-collection mcps.yaml
@@ -283,6 +294,10 @@ def run(
     # Load MCPs from registry
     metacoder run "Fetch a webpage" --registry metacoder.basics --enable-mcp fetch
 
+    \b
+    # Combine instructions with MCP configuration
+    metacoder run "Analyze data" --instructions guide.md --mcp-collection tools.yaml
+
     \b
     # Load all MCPs from registry
     metacoder run "Process PDF" --registry metacoder --enable-mcp pdfreader
@@ -419,6 +434,16 @@ def run(
     except Exception as e:
         raise click.ClickException(f"Failed to create coder: {e}")
 
+    # Load instructions if provided
+    if instructions:
+        try:
+            with open(instructions, "r") as f:
+                instructions_content = f.read()
+            coder_instance.set_instructions(instructions_content)
+            click.echo(f"📋 Loaded instructions from: {instructions}")
+        except Exception as e:
+            raise click.ClickException(f"Failed to load instructions file: {e}")
+
     # Run the coder
     click.echo(f"🚀 Running prompt: {prompt}")
     result = coder_instance.run(prompt)