gitcode-api 1.2.4__py3-none-any.whl → 1.2.5__py3-none-any.whl

gitcode_api/_cli_banner.py

@@ -1,7 +1,7 @@
 """ASCII art banner for command-line interface."""
 
-from functools import lru_cache
 import sys
+from functools import lru_cache
 
 # ANSI Colour Codes
 CREDBG = "\033[41m"

gitcode_api/cli.py

@@ -1,6 +1,7 @@
 """Command-line interface for the GitCode SDK."""
 
 import argparse
+import asyncio
 import inspect
 import json
 import re
@@ -73,8 +74,10 @@ def _argument_kwargs(parameter: inspect.Parameter) -> dict[str, Any]:
 
 
 def _first_doc_line(obj: Any) -> str:
-    doc = inspect.getdoc(obj).removeprefix("Synchronous ").capitalize() or ""
-    for line in doc.splitlines():
+    doc = inspect.getdoc(obj)
+    if doc is not None:
+        doc = doc.removeprefix("Synchronous ").capitalize()
+    for line in (doc or "").splitlines():
         stripped = line.strip()
         if stripped:
             return _plain_cli_inline(stripped)
@@ -190,6 +193,22 @@ def _root_banner() -> str:
     return "Connection and defaults are documented on each method's help: %(prog)s RESOURCE METHOD -h."
 
 
+def _serve_parser() -> argparse.ArgumentParser:
+    """Parser with options for starting the bundled MCP server."""
+    parser = argparse.ArgumentParser(add_help=False)
+    parser.add_argument("--name", default="GitCode API", help="MCP server name.")
+    parser.add_argument("--api-key", help=f"GitCode access token. Defaults to {DEFAULT_TOKEN_ENV}.")
+    parser.add_argument("--owner", help="Default repository owner.")
+    parser.add_argument("--repo", help="Default repository name.")
+    parser.add_argument("--base-url", default=DEFAULT_BASE_URL, help="Base URL for the REST API.")
+    parser.add_argument("--timeout", type=float, default=None, help="Request timeout in seconds.")
+    parser.add_argument("--transport", default="stdio", help="FastMCP transport to run, such as stdio or http.")
+    parser.add_argument("--host", default=None, help="Host for HTTP-based transports.")
+    parser.add_argument("--port", type=int, default=None, help="Port for HTTP-based transports.")
+    parser.add_argument("--path", default=None, help="Path for HTTP-based transports.")
+    return parser
+
+
 def build_parser() -> argparse.ArgumentParser:
     """Build main parser."""
     common = _invocation_parent_parser()
@@ -221,13 +240,24 @@ Each method -h opens with resource.method_signature("<name>") from the Python SD
             dest="resource",
             required=True,
             metavar="RESOURCE",
-            title="resources",
-            description="Pick a resource group (same attribute names as on GitCode, e.g. pulls, repos).",
+            title="commands",
+            description="Pick a command or resource group (same attribute names as on GitCode, e.g. pulls, repos).",
         )
+        serve_parser = resource_parsers.add_parser(
+            "serve",
+            help="Start the bundled GitCode MCP server.",
+            description="Start a FastMCP server exposing the gitcode_api_tool.",
+            formatter_class=_CLIHelpFormatter,
+            parents=[_serve_parser()],
+        )
+        serve_parser.set_defaults(command="serve")
+
         for resource_name, resource_type in _resource_types().items():
             resource = getattr(client, resource_name)
-            class_doc = inspect.getdoc(resource_type).removeprefix("Synchronous ").capitalize() or ""
-            class_lead = class_doc.split("\n\n", maxsplit=1)[0].strip() if class_doc else ""
+            class_doc = inspect.getdoc(resource_type)
+            if class_doc is not None:
+                class_doc = class_doc.removeprefix("Synchronous ").capitalize()
+            class_lead = (class_doc or "").split("\n\n", maxsplit=1)[0].strip() if class_doc else ""
             class_lead = _plain_cli_inline(class_lead) if class_lead else ""
             resource_desc_parts = [
                 class_lead or _first_doc_line(resource_type),
@@ -254,8 +284,10 @@ Each method -h opens with resource.method_signature("<name>") from the Python SD
             for method_name in resource.methods:
                 method = getattr(resource, method_name)
                 sig_line = resource.method_signature(method_name)
-                doc = inspect.getdoc(method).removeprefix("Synchronous ").capitalize() or ""
-                summary = _method_cli_summary(doc)
+                doc = inspect.getdoc(method)
+                if doc is not None:
+                    doc = doc.removeprefix("Synchronous ").capitalize()
+                summary = _method_cli_summary(doc or "")
                 if summary and len(summary) > 90:
                     method_help = summary[:87] + "..."
                 else:
@@ -306,6 +338,29 @@ Each method -h opens with resource.method_signature("<name>") from the Python SD
     return parser
 
 
+def _run_mcp_server(args: argparse.Namespace) -> int:
+    """Start the bundled FastMCP server."""
+    from .llm import create_mcp_server
+    from .llm._tool import GitCodeLLMTool
+
+    tool = GitCodeLLMTool(
+        api_key=args.api_key,
+        owner=args.owner,
+        repo=args.repo,
+        base_url=args.base_url,
+        timeout=args.timeout,
+    )
+    server = create_mcp_server(name=args.name, tool=tool)
+    run_kwargs: dict[str, Any] = {"transport": args.transport}
+    for key in ("host", "port", "path"):
+        value = getattr(args, key)
+        if value is not None:
+            run_kwargs[key] = value
+
+    server.run(**run_kwargs)
+    return 0
+
+
 def _collect_kwargs(args: argparse.Namespace, method: Any) -> dict[str, Any]:
     signature = inspect.signature(method)
     kwargs: dict[str, Any] = {}
@@ -350,6 +405,9 @@ def main(argv: Optional[Sequence[str]] = None) -> int:
     args = parser.parse_args(effective)
 
     try:
+        if getattr(args, "command", None) == "serve":
+            return _run_mcp_server(args)
+
         with GitCode(
             api_key=args.api_key,
             owner=args.owner,
@@ -360,7 +418,7 @@ def main(argv: Optional[Sequence[str]] = None) -> int:
             resource = getattr(client, args.resource_name)
             method = getattr(resource, args.method_name)
             result = method(**_collect_kwargs(args, method))
-    except (GitCodeError, OSError, TypeError, ValueError) as exc:  # pragma: no cover - integration style
+    except (GitCodeError, ImportError, OSError, TypeError, ValueError) as exc:  # pragma: no cover - integration style
         print(f"error: {exc}", file=sys.stderr)
         return 1
 

gitcode_api/llm/__init__.py

@@ -0,0 +1,49 @@
+"""LLM tool adapters for the GitCode SDK."""
+
+from importlib import import_module
+from typing import TYPE_CHECKING, Any, Dict
+
+if TYPE_CHECKING:
+    from .mcp import GitCodeMCP, create_mcp_gitcode_api_tool, create_mcp_server, register_mcp_gitcode_api_tool
+    from .openai import GitCodeOpenAITool
+
+
+_IMPORT_MAP = {
+    "GitCodeMCP": ".mcp",
+    "create_mcp_gitcode_api_tool": ".mcp",
+    "create_mcp_server": ".mcp",
+    "register_mcp_gitcode_api_tool": ".mcp",
+    "GitCodeOpenAITool": ".openai",
+}
+
+_IMPORT_CACHE: Dict[str, Any] = {}
+
+
+def __getattr__(name: str) -> object:
+    """Lazily import LLM adapter class / helper functions."""
+    value = _IMPORT_CACHE.get(name)
+    if value is not None:
+        return value
+    try:
+        module_name = _IMPORT_MAP[name]
+    except KeyError as exc:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}") from exc
+
+    module = import_module(module_name, __name__)
+    for attr in module.__all__:
+        _IMPORT_CACHE[attr] = getattr(module, attr)
+    return _IMPORT_CACHE[name]
+
+
+def __dir__() -> list[str]:
+    """Return module attributes."""
+    return __all__
+
+
+__all__ = [
+    "GitCodeOpenAITool",
+    "GitCodeMCP",
+    "create_mcp_gitcode_api_tool",
+    "create_mcp_server",
+    "register_mcp_gitcode_api_tool",
+]

gitcode_api/llm/_tool.py

@@ -0,0 +1,368 @@
+"""Shared GitCode API tool logic for LLM integrations."""
+
+import base64
+import inspect
+import logging
+from collections.abc import Mapping
+from functools import lru_cache
+import os
+from typing import Any, Callable, Dict, Optional, Tuple
+
+from gitcode_api import (
+    AsyncGitCode,
+    GitCode,
+    GitCodeConfigurationError,
+    GitCodeError,
+    GitCodeHTTPStatusError,
+)
+from gitcode_api._base_client import DEFAULT_BASE_URL, DEFAULT_TOKEN_ENV
+from gitcode_api.resources._shared import AsyncResource, SyncResource
+
+logger = logging.getLogger(__name__)
+
+OP_TYPES = frozenset(
+    name
+    for name, annotation in GitCode.__annotations__.items()
+    if inspect.isclass(annotation) and issubclass(annotation, SyncResource)
+)
+OP_TYPE_ENUM = sorted(OP_TYPES)
+TOOL_NAME = "gitcode_api_tool"
+TOOL_DESCRIPTION = (
+    "Call the GitCode REST API through the gitcode-api SDK. Use op_type to choose a client resource group, "
+    "action as the resource method name, and params as the keyword arguments for that method. Set help=true to "
+    "inspect available resource methods or a target method signature without sending an API request."
+)
+TOOL_PARAMETERS = {
+    "type": "object",
+    "properties": {
+        "op_type": {
+            "type": "string",
+            "enum": OP_TYPE_ENUM,
+            "description": "SDK resource group matching client.<op_type>, such as repos, issues, or pulls.",
+        },
+        "action": {
+            "type": "string",
+            "description": "Method name on the selected resource, such as get or list. Omit for method help.",
+        },
+        "params": {
+            "type": "object",
+            "description": "Keyword arguments passed to the SDK method. Omitted or null is treated as {}.",
+        },
+        "help": {
+            "type": "boolean",
+            "description": "When true, return dynamic SDK help instead of sending a request.",
+            "default": False,
+        },
+    },
+    "required": ["op_type"],
+}
+HELP_MESSAGE_TEMPLATE = """This is a help message, pass in help=false for normal usage.
+{header}
+Resource: {op_type}
+
+{actions_block}
+{footer}""".strip()
+_INTROSPECT_API_KEY = "introspection-only"
+
+
+def error_dict(message: str, **extra: Any) -> Dict[str, Any]:
+    """Return a normalized tool error payload."""
+    out = {"error": True, "message": message}
+    out.update(extra)
+    return out
+
+
+def serialize(value: Any) -> Any:
+    """Convert SDK responses into JSON-serializable values for tool clients."""
+    if value is None or isinstance(value, (bool, int, float, str)):
+        return value
+    if isinstance(value, bytes):
+        return {
+            "encoding": "base64",
+            "data": base64.b64encode(value).decode("ascii"),
+        }
+    if isinstance(value, dict):
+        return {key: serialize(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [serialize(item) for item in value]
+    to_dict = getattr(value, "to_dict", None)
+    if callable(to_dict):
+        return serialize(to_dict())
+    if isinstance(value, Mapping):
+        return {key: serialize(item) for key, item in dict(value).items()}
+    return str(value)
+
+
+def _actions_block(resource: Any) -> str:
+    lines = [resource.method_signature(name) for name in resource.methods]
+    return "\n".join(lines) if lines else "(no public methods)"
+
+
+def _format_help(*, op_type: str, resource: Any, header: str, footer: str = "") -> str:
+    block = _actions_block(resource) if resource is not None else ""
+    return HELP_MESSAGE_TEMPLATE.format(
+        header=header,
+        op_type=op_type,
+        actions_block=block,
+        footer=footer,
+    ).strip()
+
+
+@lru_cache(maxsize=1)
+def introspection_client() -> GitCode:
+    """Return a no-network client used only to inspect resource signatures."""
+    return GitCode(api_key=_INTROSPECT_API_KEY)
+
+
+@lru_cache(maxsize=None)
+def resource_for_op_type(op_type: str) -> SyncResource:
+    """Return the sync resource used for signature and method discovery."""
+    return getattr(introspection_client(), op_type)
+
+
+def _format_action_help(*, op_type: str, resource: Any, action: str) -> str:
+    try:
+        sig_line = resource.method_signature(action)
+    except (TypeError, ValueError, AttributeError):
+        sig_line = f"{action}(...)"
+    header = f"Target signature:\n{sig_line}"
+    return _format_help(op_type=op_type, resource=None, header=header)
+
+
+def validate_call_kwargs(
+    fn: Callable[..., Any], params: Optional[Dict[str, Any]]
+) -> Tuple[Optional[Dict[str, Any]], Optional[str]]:
+    """Return validated keyword arguments and an optional error message."""
+    raw = dict(params) if params else {}
+    try:
+        sig = inspect.signature(fn)
+    except (TypeError, ValueError) as exc:
+        return None, f"Cannot inspect signature: {exc}"
+
+    allowed = set()
+    required = []
+    accepts_var_kwargs = False
+    for name, param in sig.parameters.items():
+        if param.kind is inspect.Parameter.VAR_POSITIONAL:
+            continue
+        if param.kind is inspect.Parameter.VAR_KEYWORD:
+            accepts_var_kwargs = True
+            continue
+        allowed.add(name)
+        if param.default is inspect.Parameter.empty:
+            required.append(name)
+
+    unknown = sorted(key for key in raw if key not in allowed)
+    if unknown and not accepts_var_kwargs:
+        return None, f"Unknown parameter(s): {', '.join(unknown)}. Allowed: {', '.join(sorted(allowed))}"
+
+    missing = [key for key in required if key not in raw]
+    if missing:
+        return None, f"Missing required parameter(s): {', '.join(missing)}"
+
+    if accepts_var_kwargs:
+        return raw, None
+    return {key: value for key, value in raw.items() if key in allowed}, None
+
+
+class GitCodeLLMTool:
+    """Callable GitCode API tool shared by OpenAI and MCP adapters.
+
+    :param client: Optional synchronous GitCode client.
+    :param async_client: Optional asynchronous GitCode client.
+    :param api_key: Personal access token used when clients are not supplied.
+    :param owner: Default repository owner for generated clients.
+    :param repo: Default repository name for generated clients.
+    :param base_url: Base URL for generated clients.
+    :param timeout: Request timeout for generated clients.
+    :param decrypt: Optional decryption function for encrypted access tokens.
+    """
+
+    def __init__(
+        self,
+        *,
+        client: Optional[GitCode] = None,
+        async_client: Optional[AsyncGitCode] = None,
+        api_key: Optional[str] = None,
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: Optional[float] = None,
+        decrypt: Optional[Callable] = None,
+    ) -> None:
+        """Create a reusable tool with lazy sync and async clients."""
+        if not (api_key or os.getenv(DEFAULT_TOKEN_ENV)):
+            raise GitCodeConfigurationError("No API key provided. Pass api_key=... or set GITCODE_ACCESS_TOKEN.")
+        self._client = client
+        self._async_client = async_client
+        self._client_kwargs = {
+            "api_key": api_key,
+            "owner": owner,
+            "repo": repo,
+            "base_url": base_url,
+            "timeout": timeout,
+            "decrypt": decrypt,
+        }
+
+    @property
+    def client(self) -> GitCode:
+        """Return the synchronous client, creating it lazily when needed."""
+        if self._client is None:
+            self._client = GitCode(**self._client_kwargs)  # type: ignore[arg-type]
+        return self._client
+
+    @property
+    def async_client(self) -> AsyncGitCode:
+        """Return the asynchronous client, creating it lazily when needed."""
+        if self._async_client is None:
+            self._async_client = AsyncGitCode(**self._client_kwargs)  # type: ignore[arg-type]
+        return self._async_client
+
+    def __call__(
+        self,
+        op_type: str,
+        action: str = "",
+        params: Optional[Dict[str, Any]] = None,
+        help: bool = False,
+        **kwargs,
+    ) -> Any:
+        """Invoke a synchronous GitCode SDK method through the tool contract."""
+        if kwargs:
+            return error_dict('Invalid tool invoke, API parameters should go into "params"')
+        return self._invoke(op_type=op_type, action=action, params=params, help=help)
+
+    async def __async_call__(
+        self,
+        op_type: str,
+        action: str = "",
+        params: Optional[Dict[str, Any]] = None,
+        help: bool = False,
+        **kwargs,
+    ) -> Any:
+        """Invoke an asynchronous GitCode SDK method through the tool contract."""
+        if kwargs:
+            return error_dict('Invalid tool invoke, API parameters should go into "params"')
+        return await self._ainvoke(op_type=op_type, action=action, params=params, help=help)
+
+    def _validate_action(
+        self,
+        *,
+        op_type: str,
+        action: str,
+        params: Optional[Dict[str, Any]],
+        help: bool,
+    ) -> Tuple[Optional[str], Optional[Dict[str, Any]], Any]:
+        if op_type not in OP_TYPES:
+            allowed = ", ".join(OP_TYPE_ENUM)
+            msg = f"Invalid op_type {op_type!r}. Allowed: {allowed}"
+            if help:
+                return (
+                    HELP_MESSAGE_TEMPLATE.format(
+                        header=msg,
+                        op_type="(invalid)",
+                        actions_block="",
+                        footer="",
+                    ).strip(),
+                    None,
+                    None,
+                )
+            return str(error_dict(msg, op_type=op_type)), None, None
+
+        resource = resource_for_op_type(op_type)
+        action = (action or "").strip()
+        if not action:
+            header = "Specify non-empty action to invoke a method. Available methods:"
+            return _format_help(op_type=op_type, resource=resource, header=header), None, None
+
+        if action not in resource.methods:
+            msg = f"Unknown action {action!r} for op_type={op_type!r}."
+            if help:
+                footer = f"\n({msg})"
+                return (
+                    _format_help(op_type=op_type, resource=resource, header="Available methods:", footer=footer),
+                    None,
+                    None,
+                )
+            return str(error_dict(msg, op_type=op_type, action=action)), None, None
+
+        if help:
+            return _format_action_help(op_type=op_type, resource=resource, action=action), None, None
+
+        method = getattr(resource, action)
+        call_kwargs, verr = validate_call_kwargs(method, params)
+        if verr is not None:
+            if help:
+                try:
+                    sig_line = resource.method_signature(action)
+                except (TypeError, ValueError, AttributeError):
+                    sig_line = f"{action}(...)"
+                header = f"{verr}\n\nTarget signature:\n{sig_line}"
+                return _format_help(op_type=op_type, resource=None, header=header), None, None
+            return str(error_dict(verr, op_type=op_type, action=action)), None, None
+
+        return None, call_kwargs or {}, resource
+
+    def _handle_exception(self, exc: Exception, *, op_type: str, resource: Any, help: bool) -> Dict[str, Any]:
+        if isinstance(exc, GitCodeConfigurationError):
+            return error_dict(str(exc), kind="configuration")
+        if isinstance(exc, GitCodeHTTPStatusError):
+            return error_dict(
+                str(exc),
+                kind="http",
+                status_code=getattr(exc, "status_code", None),
+                payload=getattr(exc, "payload", None),
+            )
+        if isinstance(exc, GitCodeError):
+            return error_dict(str(exc), kind="gitcode_api")
+
+        logger.exception("gitcode_api_tool: unexpected error")
+        return error_dict(f"Unexpected error: {exc}", kind="unexpected")
+
+    def _invoke(
+        self,
+        *,
+        op_type: str,
+        action: str,
+        params: Optional[Dict[str, Any]],
+        help: bool,
+    ) -> Any:
+        validation_result, call_kwargs, resource = self._validate_action(
+            op_type=op_type,
+            action=action,
+            params=params,
+            help=help,
+        )
+        if validation_result is not None:
+            return validation_result
+
+        try:
+            result = getattr(getattr(self.client, op_type), action)(**(call_kwargs or {}))
+        except Exception as exc:  # pylint: disable=broad-exception-caught
+            return self._handle_exception(exc, op_type=op_type, resource=resource, help=help)
+        return serialize(result)
+
+    async def _ainvoke(
+        self,
+        *,
+        op_type: str,
+        action: str,
+        params: Optional[Dict[str, Any]],
+        help: bool,
+    ) -> Any:
+        validation_result, call_kwargs, resource = self._validate_action(
+            op_type=op_type,
+            action=action,
+            params=params,
+            help=help,
+        )
+        if validation_result is not None:
+            return validation_result
+
+        try:
+            async_resource = getattr(self.async_client, op_type)
+            if not isinstance(async_resource, AsyncResource):
+                raise TypeError(f"client.{op_type} is not an async resource")
+            result = await getattr(async_resource, action)(**(call_kwargs or {}))
+        except Exception as exc:  # pylint: disable=broad-exception-caught
+            return self._handle_exception(exc, op_type=op_type, resource=resource, help=help)
+        return serialize(result)

gitcode_api/llm/mcp.py

@@ -0,0 +1,93 @@
+"""FastMCP integration for the GitCode SDK LLM tool."""
+
+from typing import TYPE_CHECKING, Any, Callable, Optional, Union
+
+from ._tool import TOOL_DESCRIPTION, TOOL_NAME, GitCodeLLMTool
+
+if TYPE_CHECKING:
+    from fastmcp import FastMCP
+    from fastmcp.tools import Tool
+
+
+def _missing_fastmcp_error() -> ImportError:
+    return ImportError("FastMCP support requires the optional dependency: pip install 'gitcode-api[mcp]'")
+
+
+def _load_fastmcp() -> tuple["type[FastMCP]", Callable[..., "Tool"]]:
+    try:
+        from fastmcp import FastMCP
+        from fastmcp.tools import tool as fastmcp_tool
+    except ImportError as exc:
+        raise _missing_fastmcp_error() from exc
+    return FastMCP, fastmcp_tool  # type: ignore[return-value]
+
+
+def create_mcp_gitcode_api_tool(tool: Optional[GitCodeLLMTool] = None) -> Any:
+    """Return the async callable that can be registered with an MCP server.
+
+    :param tool: Optional preconfigured shared GitCode LLM tool.
+    :returns: Async callable using the standard GitCode tool parameters.
+    """
+    wrapped = tool or GitCodeLLMTool()
+
+    async def gitcode_api_tool(
+        op_type: str, action: str = "", params: Optional[dict[str, Any]] = None, help: bool = False
+    ) -> Any:
+        """Call GitCode SDK resources using op_type, action, and params."""
+        return await wrapped.__async_call__(op_type=op_type, action=action, params=params, help=help)
+
+    gitcode_api_tool.__name__ = TOOL_NAME
+    gitcode_api_tool.__doc__ = TOOL_DESCRIPTION
+    return gitcode_api_tool
+
+
+def register_mcp_gitcode_api_tool(mcp: Union["FastMCP", Any], tool: Optional[GitCodeLLMTool] = None) -> Any:
+    """Register the GitCode API tool with an existing FastMCP-compatible server.
+
+    :param mcp: FastMCP server instance.
+    :param tool: Optional preconfigured shared GitCode LLM tool.
+    :returns: The registered tool callable.
+    """
+    callable_tool = create_mcp_gitcode_api_tool(tool)
+    if hasattr(mcp, "tool"):
+        try:
+            return mcp.tool(name=TOOL_NAME, description=TOOL_DESCRIPTION)(callable_tool)
+        except TypeError:
+            return mcp.tool()(callable_tool)
+    if hasattr(mcp, "add_tool"):
+        _, fastmcp_tool = _load_fastmcp()
+        mcp_tool = fastmcp_tool(callable_tool, name=TOOL_NAME, description=TOOL_DESCRIPTION)
+        return mcp.add_tool(mcp_tool)
+    raise TypeError("mcp must provide a tool decorator or add_tool method")
+
+
+class GitCodeMCP:
+    """Small FastMCP server wrapper exposing the GitCode API tool.
+
+    :param name: MCP server name.
+    :param tool: Optional preconfigured shared GitCode LLM tool.
+    :param kwargs: Forwarded to ``fastmcp.FastMCP``.
+    """
+
+    def __init__(self, name: str = "GitCode API", tool: Optional[GitCodeLLMTool] = None, **kwargs) -> None:
+        """Create a FastMCP server and register the GitCode API tool."""
+        fastmcp, *_ = _load_fastmcp()
+        self.mcp = fastmcp(name, **kwargs)
+        self.gitcode_api_tool = register_mcp_gitcode_api_tool(self.mcp, tool)
+
+    def __getattr__(self, name: str) -> Any:
+        """Delegate unknown attributes to the wrapped FastMCP server."""
+        return getattr(self.mcp, name)
+
+
+def create_mcp_server(name: str = "GitCode API", tool: Optional[GitCodeLLMTool] = None, **kwargs) -> "FastMCP":
+    """Create a FastMCP server with the GitCode API tool already registered."""
+    return GitCodeMCP(name=name, tool=tool, **kwargs).mcp
+
+
+__all__ = [
+    "GitCodeMCP",
+    "create_mcp_gitcode_api_tool",
+    "create_mcp_server",
+    "register_mcp_gitcode_api_tool",
+]