drupal-mcp-server 0.1.0__py3-none-any.whl

drupal_mcp_server/clients/drush.py

@@ -0,0 +1,150 @@
+"""Drush command client."""
+
+import asyncio
+import json
+import shlex
+from typing import Any
+
+
+class DrushClient:
+    """Runs drush commands as subprocesses.
+
+    ``DRUSH_PATH`` may contain arguments, so container-based setups work:
+    set it to ``ddev drush`` (or ``lander drush``) and start the MCP server
+    from the project directory.
+    """
+
+    def __init__(self, settings: Any):
+        self._drush = shlex.split(str(getattr(settings, "DRUSH_PATH", "drush") or "drush"))
+        if not self._drush:
+            self._drush = ["drush"]
+        self._alias = str(getattr(settings, "DRUSH_ALIAS", "") or "")
+        self._timeout = 120  # seconds
+
+    def _command(self, command: str, args: list[str], with_format: bool = True) -> list[str]:
+        argv = list(self._drush)
+        if self._alias:
+            argv.append(self._alias)
+        argv.append(command)
+        # Many tools already pass --format=json themselves; adding it twice is
+        # sloppy, and commands like `drush cron` reject the option outright.
+        if with_format and not any(a.startswith("--format") for a in args):
+            argv.append("--format=json")
+        argv += args
+        return argv
+
+    @staticmethod
+    def _flatten(parts: tuple[Any, ...]) -> list[str]:
+        """Turn whatever a tool passes into a list of argv tokens.
+
+        Call sites spell a command line every way there is: `run(*cmd)` with
+        eight separate tokens, `run("config:set", [a, b, c])`, and
+        `run("config:set", "a b c")`. Treating a string as a sequence turned
+        the last form into one argument per character, so it never worked.
+        """
+        tokens: list[str] = []
+        for part in parts:
+            if part is None:
+                continue
+            if isinstance(part, str):
+                tokens.extend(shlex.split(part) if part.split() else ([part] if part else []))
+            elif isinstance(part, (list, tuple)):
+                # Items in a list are already argv tokens and must be passed
+                # through whole. Splitting each one destroyed anything holding
+                # a space: `sql:query ["SHOW TABLES"]` became two arguments, so
+                # drush answered "Too many arguments", and PHP handed to
+                # php:eval was shredded before it ever reached Drupal.
+                for item in part:
+                    if item is None:
+                        continue
+                    tokens.append(str(item))
+            else:
+                tokens.append(str(part))
+        return tokens
+
+    async def run(self, *parts: Any, cwd: str | None = None) -> dict[str, Any]:
+        """Run a drush command line.
+
+        Accepts the command plus any number of argument tokens, in any
+        combination of strings and lists::
+
+            run("cron")
+            run("status", ["--format=json"])
+            run("config:set", "twig.config", "debug", "true")
+            run(*("user:role:add", "authenticated", "1"))
+        """
+        if not parts:
+            return {
+                "returncode": 1,
+                "data": {},
+                "stderr": "No drush command was given.",
+                "command": "",
+            }
+        command, rest = str(parts[0]), parts[1:]
+        argv = self._flatten(rest)
+        cmd = self._command(command, argv)
+        result = await self._exec(cmd, cwd)
+        # `drush cron` and friends have no --format option. Retry once without
+        # it rather than failing a command that would otherwise succeed.
+        if result["returncode"] != 0 and "--format" in result.get("stderr", ""):
+            retried = await self._exec(self._command(command, argv, with_format=False), cwd)
+            # Report the run that actually executed. Returning the original
+            # made every failure read as "The --format option does not exist",
+            # which buries the real reason.
+            retried["format_flag_dropped"] = True
+            return retried
+        return result
+
+    async def _exec(self, cmd: list[str], cwd: str | None) -> dict[str, Any]:
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                *cmd,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                cwd=cwd,
+            )
+        except FileNotFoundError:
+            # Without a distinct message every drush tool just reports
+            # "No such file or directory", which reads like a product bug.
+            return {
+                "returncode": 127,
+                "data": {},
+                "stderr": (
+                    f"Drush executable {cmd[0]!r} not found on PATH. "
+                    "Set DRUSH_PATH to a working command (for example "
+                    "'ddev drush') and start the MCP server from the project "
+                    "directory."
+                ),
+                "command": " ".join(cmd),
+            }
+        except PermissionError:
+            return {
+                "returncode": 126,
+                "data": {},
+                "stderr": f"Drush executable {cmd[0]!r} is not executable.",
+                "command": " ".join(cmd),
+            }
+
+        try:
+            stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=self._timeout)
+        except TimeoutError:  # asyncio.TimeoutError is an alias on 3.11+
+            proc.kill()
+            return {
+                "returncode": -1,
+                "data": {},
+                "stderr": f"Command timed out after {self._timeout}s",
+                "command": " ".join(cmd),
+            }
+        try:
+            data = json.loads(stdout.decode()) if stdout else {}
+        except json.JSONDecodeError:
+            data = {"output": stdout.decode()}
+        return {
+            "returncode": proc.returncode,
+            "data": data,
+            "stderr": stderr.decode(),
+            "command": " ".join(cmd),
+        }
+
+    async def status(self) -> dict[str, Any]:
+        return await self.run("status")

drupal_mcp_server/clients/graphql.py

@@ -0,0 +1,182 @@
+"""GraphQL client for Drupal."""
+
+from typing import Any
+
+from .base import DrupalBaseClient
+
+# Standard GraphQL introspection query; enough to render both JSON and SDL.
+_INTROSPECTION_QUERY = """
+query IntrospectionQuery {
+  __schema {
+    queryType { name }
+    mutationType { name }
+    subscriptionType { name }
+    types { ...FullType }
+    directives {
+      name
+      description
+      locations
+      args { ...InputValue }
+    }
+  }
+}
+fragment FullType on __Type {
+  kind
+  name
+  description
+  fields(includeDeprecated: true) {
+    name
+    description
+    args { ...InputValue }
+    type { ...TypeRef }
+    isDeprecated
+    deprecationReason
+  }
+  inputFields { ...InputValue }
+  interfaces { ...TypeRef }
+  enumValues(includeDeprecated: true) {
+    name
+    description
+    isDeprecated
+    deprecationReason
+  }
+  possibleTypes { ...TypeRef }
+}
+fragment InputValue on __InputValue {
+  name
+  description
+  type { ...TypeRef }
+  defaultValue
+}
+fragment TypeRef on __Type {
+  kind
+  name
+  ofType {
+    kind
+    name
+    ofType {
+      kind
+      name
+      ofType {
+        kind
+        name
+      }
+    }
+  }
+}
+"""
+
+
+def _type_ref(ref: dict[str, Any] | None) -> str:
+    """Render a nested __Type reference as GraphQL SDL syntax."""
+    if not ref:
+        return "unknown"
+    inner = ref.get("ofType")
+    if inner:
+        rendered = _type_ref(inner)
+    else:
+        rendered = ref.get("name") or "unknown"
+    kind = ref.get("kind")
+    if kind == "LIST":
+        return f"[{rendered}]"
+    if kind == "NON_NULL":
+        return f"{rendered}!"
+    return rendered
+
+
+def _args(args: list[dict[str, Any]] | None) -> str:
+    if not args:
+        return ""
+    return "(" + ", ".join(f"{a['name']}: {_type_ref(a.get('type'))}" for a in args) + ")"
+
+
+def _render_type(t: dict[str, Any]) -> str | None:
+    name = t.get("name")
+    if not name or name.startswith("__"):
+        return None
+    kind = t.get("kind")
+
+    if kind == "SCALAR":
+        return f"scalar {name}"
+    if kind == "UNION":
+        members = [p["name"] for p in (t.get("possibleTypes") or [])]
+        return f"union {name} = {' | '.join(members)}" if members else f"union {name}"
+    if kind == "ENUM":
+        values = [v["name"] for v in (t.get("enumValues") or [])]
+        body = "\n".join(f"  {v}" for v in values)
+        return f"enum {name} {{\n{body}\n}}"
+    if kind in ("OBJECT", "INTERFACE"):
+        keyword = "type" if kind == "OBJECT" else "interface"
+        ifaces = [i["name"] for i in (t.get("interfaces") or [])]
+        implements = f" implements {', '.join(ifaces)}" if ifaces else ""
+        lines = []
+        for f in t.get("fields") or []:
+            lines.append(f"  {f['name']}{_args(f.get('args'))}: {_type_ref(f.get('type'))}")
+        body = "\n".join(lines)
+        return f"{keyword} {name}{implements} {{\n{body}\n}}"
+    if kind == "INPUT_OBJECT":
+        lines = [
+            f"  {f['name']}: {_type_ref(f.get('type'))}"
+            for f in (t.get("inputFields") or [])
+        ]
+        body = "\n".join(lines)
+        return f"input {name} {{\n{body}\n}}"
+    return None
+
+
+class GraphQLClient(DrupalBaseClient):
+    """Client for Drupal GraphQL endpoints."""
+
+    def __init__(self, settings: Any, auth_manager: Any = None):
+        super().__init__(settings, auth_manager)
+        self._gql_path = settings.DRUPAL_GRAPHQL_PATH.strip("/")
+
+    async def execute(self, query: str, variables: dict[str, Any] | None = None) -> dict[str, Any] | list[Any]:
+        payload: dict[str, Any] = {"query": query}
+        if variables:
+            payload["variables"] = variables
+        return await self.post(self._gql_path, json_body=payload)
+
+    async def get_schema(self) -> dict[str, Any] | list[Any]:
+        """Fetch the schema via GraphQL introspection, as JSON.
+
+        Drupal's GraphQL module exposes no schema endpoint, so introspection is
+        the only portable way to read it.
+        """
+        return await self.execute(_INTROSPECTION_QUERY)
+
+    async def get_schema_sdl(self) -> str:
+        """Fetch the schema and render it as SDL text."""
+        document = await self.get_schema()
+        schema = (
+            document.get("data", {}).get("__schema")
+            if isinstance(document, dict)
+            else None
+        )
+        if not schema:
+            raise ValueError(
+                "Introspection did not return a __schema; "
+                "is the GraphQL module enabled on this site?"
+            )
+
+        blocks = []
+        for t in schema.get("types") or []:
+            rendered = _render_type(t)
+            if rendered:
+                blocks.append(rendered)
+
+        entry: list[tuple[str, str]] = []
+        for role, label in (
+            ("queryType", "query"),
+            ("mutationType", "mutation"),
+            ("subscriptionType", "subscription"),
+        ):
+            node = schema.get(role)
+            if node and node.get("name"):
+                entry.append((label, node["name"]))
+
+        header = ""
+        if entry:
+            lines = "\n".join(f"  {label}: {name}" for label, name in entry)
+            header = f"schema {{\n{lines}\n}}\n\n"
+        return header + "\n\n".join(blocks) + "\n"

drupal_mcp_server/clients/jsonapi.py

@@ -0,0 +1,248 @@
+"""JSON:API client for Drupal."""
+
+import re
+from typing import Any
+
+from .base import DrupalBaseClient
+
+# JSON:API addresses single resources by UUID. Drupal's internal IDs (nid, uid,
+# tid, ...) are not usable in the path and must be resolved with a filter.
+_UUID_RE = re.compile(
+    r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
+)
+
+# Internal ID field names across core entity types, probed in order.
+_ID_FIELDS = (
+    "drupal_internal__nid",
+    "drupal_internal__uid",
+    "drupal_internal__tid",
+    "drupal_internal__vid",
+    "drupal_internal__mid",
+    "drupal_internal__cid",
+    "drupal_internal__fid",
+    "drupal_internal__lid",
+    "drupal_internal__id",
+)
+
+
+class JSONAPIClient(DrupalBaseClient):
+    """Client for Drupal JSON:API endpoints."""
+
+    # Drupal answers any other Content-Type with 415 Unsupported Media Type.
+    _media_type = "application/vnd.api+json"
+
+    def __init__(self, settings: Any, auth_manager: Any = None):
+        super().__init__(settings, auth_manager)
+        self._api_path = settings.DRUPAL_JSONAPI_PATH.strip("/")
+        self._index_paths: dict[str, str] | None = None
+
+    def _jsonapi_url(self, resource: str) -> str:
+        return f"{self._api_path}/{resource.lstrip('/')}"
+
+    async def get_index(self) -> dict[str, Any] | list[Any]:
+        """Fetch the JSON:API root, which lists available resources.
+
+        Hits ``/jsonapi`` directly. Do not route this through
+        :meth:`get_resource`, which would produce ``/jsonapi/jsonapi``.
+        """
+        return await self.get(self._api_path)
+
+    async def _path_map(self) -> dict[str, str]:
+        """Map JSON:API resource types (``node--article``) to URL paths.
+
+        Drupal serves resources at ``/jsonapi/node/article`` while the
+        *type* string used in payloads stays ``node--article``. The index is
+        the only reliable source for this mapping, and it also lets us expand
+        a bare entity type (``node``) into its bundles.
+        """
+        if self._index_paths is not None:
+            return self._index_paths
+        try:
+            index = await self.get_index()
+        except Exception:
+            self._index_paths = {}
+            return self._index_paths
+        mapping: dict[str, str] = {}
+        links = index.get("links", {}) if isinstance(index, dict) else {}
+        prefix = f"/{self._api_path}/"
+        for key, value in links.items():
+            if key == "self" or not isinstance(value, dict):
+                continue
+            href = str(value.get("href", ""))
+            marker = href.find(prefix)
+            if marker == -1:
+                continue
+            mapping[key] = href[marker + len(prefix):].split("?")[0]
+        self._index_paths = mapping
+        return mapping
+
+    async def _candidates(self, resource_type: str) -> list[str]:
+        """URL path candidates for a resource type, in priority order."""
+        resource_type = resource_type.strip("/")
+        if "--" in resource_type:
+            return [resource_type.replace("--", "/")]
+        mapping = await self._path_map()
+        if resource_type in mapping:
+            return [mapping[resource_type]]
+        prefix = f"{resource_type}--"
+        found = [path for key, path in mapping.items() if key.startswith(prefix)]
+        return found or [resource_type]
+
+    async def get_resource(self, resource_type: str, params: dict[str, Any] | None = None) -> dict[str, Any] | list[Any]:
+        candidates = await self._candidates(resource_type)
+        if len(candidates) == 1:
+            return await self.get(self._jsonapi_url(candidates[0]), params=params)
+        return await self._merge(candidates, params)
+
+    async def _merge(self, candidates: list[str], params: dict[str, Any] | None) -> dict[str, Any]:
+        """Fetch several bundle collections and merge their data."""
+        merged: dict[str, Any] = {"data": [], "included": []}
+        for path in candidates:
+            try:
+                chunk = await self.get(self._jsonapi_url(path), params=params)
+            except Exception:
+                continue
+            if not isinstance(chunk, dict):
+                continue
+            merged["data"].extend(chunk.get("data") or [])
+            merged["included"].extend(chunk.get("included") or [])
+            for key in ("meta", "links"):
+                if key in chunk and key not in merged:
+                    merged[key] = chunk[key]
+        seen: set[str] = set()
+        unique: list[Any] = []
+        for item in merged["included"]:
+            item_id = item.get("id")
+            if item_id not in seen:
+                seen.add(item_id)
+                unique.append(item)
+        merged["included"] = unique
+        return merged
+
+    async def _resolve_uuid(self, resource_type: str, resource_id: str) -> tuple[str, str]:
+        """Turn an internal ID into ``(path, uuid)`` for a single resource."""
+        resource_id = str(resource_id)
+        candidates = await self._candidates(resource_type)
+
+        if _UUID_RE.match(resource_id):
+            if len(candidates) == 1:
+                return candidates[0], resource_id
+            # Bundle unknown: probe each candidate collection for the UUID.
+            for path in candidates:
+                try:
+                    await self.get(self._jsonapi_url(f"{path}/{resource_id}"))
+                except Exception:
+                    continue
+                return path, resource_id
+            return candidates[0], resource_id
+
+        matched_field: str | None = None
+        for path in candidates:
+            for field in _ID_FIELDS:
+                # Field validity is per entity type, not per bundle, so a hit
+                # (or a valid-but-empty result) is remembered across paths.
+                candidate_field = matched_field or field
+                response = await self.request(
+                    "GET",
+                    self._jsonapi_url(path),
+                    params={f"filter[{candidate_field}]": resource_id},
+                )
+                if response.status_code == 400:
+                    # Unknown filter key: try the next field name.
+                    continue
+                matched_field = candidate_field
+                if response.status_code >= 400:
+                    break
+                rows = response.json().get("data") if response.content else None
+                if rows:
+                    return path, rows[0]["id"]
+                # Valid filter, empty result: next bundle (or done).
+                break
+        raise LookupError(
+            f"No resource of type {resource_type!r} with id {resource_id!r}"
+        )
+
+    async def get_by_id(
+        self,
+        resource_type: str,
+        uuid: str,
+        params: dict[str, Any] | None = None,
+    ) -> dict[str, Any] | list[Any]:
+        """Fetch a single resource by ID, optionally with relationship includes.
+
+        Args:
+            resource_type: JSON:API resource type (e.g. ``node``, ``user--user``).
+            uuid: Resource UUID or Drupal internal ID (nid, uid, tid, ...).
+            params: Optional query params, typically ``{"include": "..."}``.
+
+        Returns:
+            Parsed JSON:API response.
+        """
+        path, resource_id = await self._resolve_uuid(resource_type, uuid)
+        return await self.get(self._jsonapi_url(f"{path}/{resource_id}"), params=params)
+
+    # Sibling keys of ``attributes`` in a JSON:API resource object. Including
+    # ``attributes`` matters: a caller that passes an already-structured
+    # document must not have it nested as attributes.attributes.
+    _RESOURCE_KEYS = frozenset(
+        {"type", "id", "lid", "attributes", "relationships", "links", "meta"}
+    )
+
+    @classmethod
+    def _payload(cls, body: Any) -> Any:
+        """Normalise a payload into JSON:API document form.
+
+        Most write tools assemble a flat dict (``{"title": ..., "type": ...}``),
+        but Drupal requires ``{"data": {"type": ..., "attributes": {...}}}`` and
+        rejects anything else with 400 "Resource object must include a type".
+        Documents that are already wrapped are passed through untouched.
+        """
+        if not isinstance(body, dict) or "data" in body or not body:
+            return body
+        resource: dict[str, Any] = {}
+        attributes: dict[str, Any] = {}
+        for key, value in body.items():
+            if key in cls._RESOURCE_KEYS:
+                resource[key] = value
+            else:
+                attributes[key] = value
+        if attributes:
+            resource["attributes"] = attributes
+        return {"data": resource}
+
+    async def get_revision(
+        self,
+        resource_type: str,
+        resource_id: str,
+        revision_id: str,
+        params: dict[str, Any] | None = None,
+    ) -> dict[str, Any] | list[Any]:
+        """Fetch one specific revision of a resource.
+
+        JSON:API reads historical revisions through the ``resourceVersion``
+        relationship (``id:<vid>``). It has no revision *collection*
+        endpoint -- ``.../revisions`` answers 405 -- so this is the only
+        revision access the module offers.
+        """
+        path, uuid = await self._resolve_uuid(resource_type, resource_id)
+        query = dict(params or {})
+        query["resourceVersion"] = f"id:{revision_id}"
+        return await self.get(self._jsonapi_url(f"{path}/{uuid}"), params=query)
+
+    async def create_resource(self, resource_type: str, data: dict[str, Any]) -> dict[str, Any] | list[Any]:
+        # The payload keeps the ``node--article`` type; only the URL is a path.
+        candidates = await self._candidates(resource_type)
+        return await self.post(self._jsonapi_url(candidates[0]), json_body=self._payload(data))
+
+    async def update_resource(self, resource_type: str, uuid: str, data: dict[str, Any]) -> dict[str, Any] | list[Any]:
+        path, resource_id = await self._resolve_uuid(resource_type, uuid)
+        body = self._payload(data)
+        # Drupal addresses the resource by UUID, not by the internal ID the
+        # caller may have passed in.
+        if isinstance(body, dict) and isinstance(body.get("data"), dict):
+            body["data"]["id"] = resource_id
+        return await self.patch(self._jsonapi_url(f"{path}/{resource_id}"), json_body=body)
+
+    async def delete_resource(self, resource_type: str, uuid: str) -> dict[str, Any] | list[Any]:
+        path, resource_id = await self._resolve_uuid(resource_type, uuid)
+        return await self.delete(self._jsonapi_url(f"{path}/{resource_id}"))

drupal_mcp_server/config.py

@@ -0,0 +1,84 @@
+"""Configuration settings for Drupal MCP Server."""
+
+from functools import lru_cache
+
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    """Application settings loaded from environment variables."""
+
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        case_sensitive=False,
+        extra="ignore",
+    )
+
+    # Drupal Connection
+    DRUPAL_BASE_URL: str = Field(default="http://localhost", description="Base URL of Drupal site")
+    DRUPAL_JSONAPI_PATH: str = Field(default="/jsonapi", description="JSON:API endpoint path")
+    DRUPAL_GRAPHQL_PATH: str = Field(default="/graphql", description="GraphQL endpoint path")
+    DRUPAL_USERNAME: str | None = Field(default=None, description="Basic auth username")
+    DRUPAL_PASSWORD: str | None = Field(default=None, description="Basic auth password")
+    DRUPAL_OAUTH_CLIENT_ID: str | None = Field(default=None, description="OAuth client ID")
+    DRUPAL_OAUTH_CLIENT_SECRET: str | None = Field(default=None, description="OAuth client secret")
+    DRUPAL_OAUTH_TOKEN_URL: str | None = Field(default=None, description="OAuth token endpoint URL")
+    DRUPAL_API_TOKEN: str | None = Field(
+        default=None,
+        description="Pre-obtained bearer token, sent as Authorization: Bearer",
+    )
+    DRUPAL_VERIFY_SSL: bool = Field(
+        default=True,
+        description="Verify TLS certificates. Set false for self-signed dev certs (DDEV, Lando).",
+    )
+
+    # Drush
+    DRUSH_PATH: str = Field(
+        default="drush",
+        description=(
+            "Drush command. May include arguments, e.g. 'ddev drush' "
+            "(start the MCP server from the project directory)."
+        ),
+    )
+    DRUSH_ALIAS: str = Field(default="@self", description="Drush site alias")
+
+    # DDEV
+    DDEV_BINARY: str = Field(default="ddev", description="Path to ddev executable")
+
+    # AI Providers
+    DEFAULT_AI_PROVIDER: str = Field(default="ollama", description="Default AI provider")
+    AI_ENABLED: bool = Field(default=True, description="Enable AI-enhanced tools")
+    AI_FALLBACK_TO_CORE: bool = Field(default=True, description="Fallback to core tools if AI fails")
+    AI_TIMEOUT: int = Field(default=60, description="AI request timeout in seconds")
+
+    # Ollama
+    OLLAMA_BASE_URL: str = Field(default="http://localhost:11434", description="Ollama API base URL")
+    OLLAMA_MODEL: str = Field(default="llama3.2:3b", description="Ollama model name")
+
+    # OpenAI
+    OPENAI_API_KEY: str | None = Field(default=None, description="OpenAI API key")
+    OPENAI_MODEL: str = Field(default="gpt-4o-mini", description="OpenAI model name")
+
+    # Anthropic
+    ANTHROPIC_API_KEY: str | None = Field(default=None, description="Anthropic API key")
+    ANTHROPIC_MODEL: str = Field(default="claude-3-5-haiku-20241022", description="Anthropic model name")
+
+    # NVIDIA NIM
+    NVIDIA_NIM_API_KEY: str | None = Field(default=None, description="NVIDIA NIM API key")
+    NVIDIA_NIM_BASE_URL: str = Field(default="https://integrate.api.nvidia.com/v1", description="NVIDIA NIM base URL")
+    NVIDIA_NIM_MODEL: str = Field(default="nvidia/nemotron-3-ultra", description="NVIDIA NIM model name")
+
+    # MCP Server
+    MCP_SERVER_NAME: str = Field(default="drupal-mcp-server", description="MCP server name")
+    MCP_TRANSPORT: str = Field(default="stdio", description="MCP transport type")
+    MCP_HOST: str = Field(default="0.0.0.0", description="MCP HTTP host")
+    MCP_PORT: int = Field(default=8000, description="MCP HTTP port")
+    MCP_LOG_LEVEL: str = Field(default="INFO", description="Logging level")
+
+
+@lru_cache
+def get_settings() -> Settings:
+    """Get cached settings instance."""
+    return Settings()