First cut at config API

Author: msabramo

src/mcp/client/config/mcp_servers_config.py

@@ -0,0 +1,62 @@
+"""Configuration management for MCP servers."""
+
+# stdlib imports
+import json
+from pathlib import Path
+from typing import Annotated, Any, Literal
+
+# third party imports
+from pydantic import BaseModel, Field, model_validator
+
+
+class MCPServerConfig(BaseModel):
+    """Base class for MCP server configurations."""
+
+    pass
+
+
+class StdioServerConfig(MCPServerConfig):
+    """Configuration for stdio-based MCP servers."""
+
+    type: Literal["stdio"] = "stdio"
+    command: str
+    args: list[str] | None = None
+    env: dict[str, str] | None = None
+
+
+class StreamableHttpConfig(MCPServerConfig):
+    """Configuration for StreamableHTTP-based MCP servers."""
+
+    type: Literal["streamable_http"] = "streamable_http"
+    url: str
+    headers: dict[str, str] | None = None
+
+
+# Discriminated union for different server config types
+ServerConfigUnion = Annotated[StdioServerConfig | StreamableHttpConfig, Field(discriminator="type")]
+
+
+class MCPServersConfig(BaseModel):
+    """Configuration for multiple MCP servers."""
+
+    servers: dict[str, ServerConfigUnion] = Field(alias="mcpServers")
+
+    @model_validator(mode="before")
+    @classmethod
+    def infer_server_types(cls, data: Any) -> Any:
+        """Automatically infer server types when 'type' field is omitted."""
+        if isinstance(data, dict) and "mcpServers" in data:
+            for _server_name, server_config in data["mcpServers"].items():  # type: ignore
+                if isinstance(server_config, dict) and "type" not in server_config:
+                    # Infer type based on distinguishing fields
+                    if "command" in server_config:
+                        server_config["type"] = "stdio"
+                    elif "url" in server_config:
+                        server_config["type"] = "streamable_http"
+        return data
+
+    @classmethod
+    def from_file(cls, config_path: Path) -> "MCPServersConfig":
+        """Load configuration from a JSON file."""
+        with open(config_path) as config_file:
+            return cls.model_validate(json.load(config_file))

tests/client/config/__init__.py

@@ -0,0 +1 @@
+ 

tests/client/config/test_mcp_servers_config.py

@@ -0,0 +1,62 @@
+# stdlib imports
+import json
+from pathlib import Path
+
+# third party imports
+import pytest
+
+# local imports
+from mcp.client.config.mcp_servers_config import (
+    MCPServersConfig,
+    StdioServerConfig,
+    StreamableHttpConfig,
+)
+
+
+@pytest.fixture
+def mcp_config_file(tmp_path: Path) -> Path:
+    """Create temporary JSON config file with mixed server types"""
+
+    config_data = {
+        "mcpServers": {
+            "stdio_server": {
+                "command": "python",
+                "args": ["-m", "my_server"],
+                "env": {"DEBUG": "true"},
+            },
+            "http_streamable": {
+                "url": "https://api.example.com/mcp",
+                "headers": {"Authorization": "Bearer token123"},
+            },
+        }
+    }
+
+    # Write to temporary file
+    config_file_path = tmp_path / "mcp.json"
+    with open(config_file_path, "w") as config_file:
+        json.dump(config_data, config_file)
+
+    return config_file_path
+
+
+def test_stdio_server(mcp_config_file: Path):
+    config = MCPServersConfig.from_file(mcp_config_file)
+
+    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"}
+    assert stdio_server.type == "stdio"  # Should be automatically inferred
+    
+
+def test_streamable_http_server(mcp_config_file: Path):
+    config = MCPServersConfig.from_file(mcp_config_file)
+
+    http_server = config.servers["http_streamable"]
+    assert isinstance(http_server, StreamableHttpConfig)
+
+    assert http_server.url == "https://api.example.com/mcp"
+    assert http_server.headers == {"Authorization": "Bearer token123"}
+    assert http_server.type == "streamable_http"  # Should be automatically inferred