Add YAML support

Author: msabramo

pyproject.toml

@@ -37,6 +37,7 @@ dependencies = [
 rich = ["rich>=13.9.4"]
 cli = ["typer>=0.12.4", "python-dotenv>=1.0.0"]
 ws = ["websockets>=15.0.1"]
+yaml = ["pyyaml>=6.0.2"]
 
 [project.scripts]
 mcp = "mcp.cli:app [cli]"

src/mcp/client/config/mcp_servers_config.py

@@ -6,6 +6,10 @@
 from typing import Annotated, Any, Literal
 
 # third party imports
+try:
+    import yaml
+except ImportError:
+    yaml = None  # type: ignore
 from pydantic import BaseModel, Field, field_validator
 
 
@@ -81,7 +85,21 @@ def infer_server_types(cls, servers_data: dict[str, Any]) -> dict[str, Any]:
         return servers_data
 
     @classmethod
-    def from_file(cls, config_path: Path) -> "MCPServersConfig":
-        """Load configuration from a JSON file."""
+    def from_file(cls, config_path: Path, use_pyyaml: bool = False) -> "MCPServersConfig":
+        """Load configuration from a JSON or YAML file.
+
+        Args:
+            config_path: Path to the configuration file
+            use_pyyaml: If True, force use of PyYAML parser. Defaults to False.
+                        Also automatically used for .yaml/.yml files.
+        """
         with open(config_path) as config_file:
-            return cls.model_validate(json.load(config_file))
+            # Check if YAML parsing is requested
+            should_use_yaml = use_pyyaml or config_path.suffix.lower() in (".yaml", ".yml")
+
+            if should_use_yaml:
+                if not yaml:
+                    raise ImportError("PyYAML is required to parse YAML files. ")
+                return cls.model_validate(yaml.safe_load(config_file))
+            else:
+                return cls.model_validate(json.load(config_file))

tests/client/config/mcp.yaml

@@ -0,0 +1,70 @@
+# MCP Servers Configuration (YAML format)
+# This file demonstrates the same server configurations as mcp.json but in YAML format
+
+mcpServers:
+  time:
+    command: uvx mcp-server-time
+
+  # Stdio server with full command string
+  # The library will automatically parse this.
+  # The effective_command will be "python" and effective_args will be ["-m", "my_server"]
+  stdio_server_with_full_command:
+    command: python -m my_server
+
+  # Streamable HTTP server with headers
+  streamable_http_server:
+    url: https://api.example.com/mcp
+
+  # Streamable HTTP server with headers
+  streamable_http_server_with_headers:
+    url: https://api.example.com/mcp
+    headers:
+      Authorization: Bearer token123
+
+  # stdio server with explicit command and args like typically done in mcp.json
+  # files
+  # I would expect this to not be used much with YAML files, but it's here for
+  # completeness.
+  stdio_server:
+    command: python
+    args:
+      - -m
+      - my_server
+    env:
+      DEBUG: "true"
+
+  # Stdio server with full command string AND explicit args
+  # The effective_args will combine parsed command args with explicit args
+  stdio_server_with_full_command_and_explicit_args:
+    command: python -m my_server  # Will be parsed to: command="python", args=["-m", "my_server"]
+    args:
+      - --debug  # Will be appended to parsed args: ["-m", "my_server", "--debug"]
+
+  # Streamable HTTP server with headers
+  streamable_http_server_with_headers:
+    url: https://api.example.com/mcp
+    headers:
+      Authorization: Bearer token123
+
+  # Servers with explicit types - these demonstrate that type inference
+  # can be overridden by explicitly specifying the "type" field
+
+  # Stdio server with explicit type specification
+  stdio_server_with_explicit_type:
+    type: stdio  # Explicitly specified type
+    command: python
+    args:
+      - -m
+      - my_server
+    env:
+      DEBUG: "true"
+
+  # Streamable HTTP server with explicit type specification
+  streamable_http_server_with_explicit_type:
+    type: streamable_http  # Explicitly specified type
+    url: https://api.example.com/mcp
+
+  # SSE (Server-Sent Events) server with explicit type specification
+  sse_server_with_explicit_type:
+    type: sse  # Explicitly specified type
+    url: https://api.example.com/sse

tests/client/config/test_yaml_functionality.py

@@ -0,0 +1,83 @@
+# stdlib imports
+from pathlib import Path
+
+# third party imports
+import pytest
+
+# local imports
+from mcp.client.config.mcp_servers_config import MCPServersConfig, StdioServerConfig, StreamableHTTPServerConfig
+
+
+@pytest.fixture
+def mcp_yaml_config_file() -> Path:
+    """Return path to the mcp.yaml config file."""
+    return Path(__file__).parent / "mcp.yaml"
+
+
+def test_yaml_extension_auto_detection(mcp_yaml_config_file: Path):
+    """Test that .yaml files are automatically parsed with PyYAML."""
+    config = MCPServersConfig.from_file(mcp_yaml_config_file)
+
+    # Should successfully load the YAML file with all 9 servers
+    assert "stdio_server" in config.servers
+    assert "streamable_http_server_with_headers" in config.servers
+    assert "sse_server_with_explicit_type" in config.servers
+
+    # Verify a specific server
+    stdio_server = config.servers["stdio_server"]
+    assert isinstance(stdio_server, StdioServerConfig)
+    assert stdio_server.command == "python"
+    assert stdio_server.args == ["-m", "my_server"]
+    assert stdio_server.env == {"DEBUG": "true"}
+
+
+def test_use_pyyaml_parameter_with_json_file():
+    """Test that use_pyyaml=True forces PyYAML parsing even for JSON files."""
+    json_file = Path(__file__).parent / "mcp.json"
+
+    # Load with PyYAML explicitly
+    config = MCPServersConfig.from_file(json_file, use_pyyaml=True)
+
+    # Should work fine - PyYAML can parse JSON
+    assert len(config.servers) == 7
+    assert "stdio_server" in config.servers
+
+    # Verify it produces the same result as normal JSON parsing
+    config_json = MCPServersConfig.from_file(json_file, use_pyyaml=False)
+    assert len(config.servers) == len(config_json.servers)
+    assert list(config.servers.keys()) == list(config_json.servers.keys())
+
+
+def test_time_server(mcp_yaml_config_file: Path):
+    """Test the time server configuration with uvx command."""
+    config = MCPServersConfig.from_file(mcp_yaml_config_file)
+
+    # Should have the time server
+    assert "time" in config.servers
+
+    # Verify the server configuration
+    time_server = config.servers["time"]
+    assert isinstance(time_server, StdioServerConfig)
+    assert time_server.type == "stdio"  # Should be auto-inferred from command field
+    assert time_server.command == "uvx mcp-server-time"
+    assert time_server.args is None  # No explicit args
+    assert time_server.env is None  # No environment variables
+
+    # Test the effective command parsing
+    assert time_server.effective_command == "uvx"
+    assert time_server.effective_args == ["mcp-server-time"]
+
+
+def test_streamable_http_server(mcp_yaml_config_file: Path):
+    """Test the new streamable HTTP server configuration without headers."""
+    config = MCPServersConfig.from_file(mcp_yaml_config_file)
+
+    # Should have the new streamable_http_server
+    assert "streamable_http_server" in config.servers
+
+    # Verify the server configuration
+    http_server = config.servers["streamable_http_server"]
+    assert isinstance(http_server, StreamableHTTPServerConfig)
+    assert http_server.type == "streamable_http"  # Should be auto-inferred
+    assert http_server.url == "https://api.example.com/mcp"
+    assert http_server.headers is None  # No headers specified