Merge pull request #27 from bearslyricattack/proxy

add mcp proxy.

Author: zzjin

Service/mcp/mcp-proxy/Dockerfile

@@ -0,0 +1,23 @@
+FROM ghcr.io/labring-actions/devbox/debian-ssh-12.6:547a61
+
+RUN cd /home/devbox/project && \rm -rf ./*
+COPY /Service/mcp/mcp-proxy/project /home/devbox/project/project
+
+
+RUN apt-get update && \
+    apt-get install -y python3 python3-pip python3-venv && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/* && \
+    ln -s /usr/bin/python3 /usr/bin/python && \
+    chown -R devbox:devbox /home/devbox/project && \
+    chmod -R u+rw /home/devbox/project && \
+    chmod -R +x /home/devbox/project/project/entrypoint.sh
+
+USER devbox
+RUN cd /home/devbox/project && \
+    python3 -m venv .venv && \
+    . .venv/bin/activate && \
+    pip3 install "mcp[cli]==1.6.0" && \
+    deactivate
+
+RUN mkdir -p /home/devbox/.devbox

Service/mcp/mcp-proxy/project/README.md

@@ -0,0 +1,28 @@
+# MCP Proxy Server Example
+
+This is an MCP format conversion tool that can expose STDIO services in the form of SSE, or vice versa.
+
+## Project Description
+
+This project is a tool used to convert MCP services at the STDIO level into SSE services, so that existing MCP STDIO programs can be developed and called on the public network.
+
+When you use this template for development, you need to write your own MCP service program and related dependencies in this template, After you have completed writing your code, modify the startup command in the entrypoint file by adding the stdio startup command for your project. For example:
+
+```
+mcp-proxy --sse-port=8080 npx @modelcontextprotocol/server-puppeteer
+```
+
+Then start the project.
+
+The source code for this project comes from https://github.com/sparfenyuk/mcp-proxy.
+
+## Environment
+
+This project runs on a Debian 12 system with Python 3.3.2 installed. The environment is pre-configured in Devbox, so you don't need to worry about setting up Python or other system dependencies yourself. If you need to make adjustments to meet your specific requirements, you can modify the configuration file accordingly.
+
+## Project Execution
+
+**Development Mode**: For a normal development environment, just enter Devbox and run "bash entrypoint.sh" in the terminal. This will compile and run the Java application.
+**Production mode:** Once published, the project will be automatically packaged into a Docker image and deployed according to the `entrypoint.sh` script (run `bash entrypoint.sh production`).
+DevBox: Code. Build. Deploy. We do the rest.
+With DevBox, you can fully focus on writing great code while we take care of infrastructure, scaling, and deployment. Seamless development from start to production.

Service/mcp/mcp-proxy/project/__init__.py

@@ -0,0 +1 @@
+"""Library for proxying MCP servers across different transports."""

Service/mcp/mcp-proxy/project/__main__.py

@@ -0,0 +1,160 @@
+"""The entry point for the mcp-proxy application. It sets up the logging and runs the main function.
+
+Two ways to run the application:
+1. Run the application as a module `uv run -m mcp_proxy`
+2. Run the application as a package `uv run mcp-proxy`
+
+"""
+
+import argparse
+import asyncio
+import logging
+import os
+import sys
+import typing as t
+
+from mcp.client.stdio import StdioServerParameters
+
+from .sse_client import run_sse_client
+from .sse_server import SseServerSettings, run_sse_server
+
+SSE_URL: t.Final[str | None] = os.getenv(
+    "SSE_URL",
+    None,
+)
+
+
+def main() -> None:
+    """Start the client using asyncio."""
+    parser = argparse.ArgumentParser(
+        description=(
+            "Start the MCP proxy in one of two possible modes: as an SSE or stdio client."
+        ),
+        epilog=(
+            "Examples:\n"
+            "  mcp-proxy http://localhost:8080/sse\n"
+            "  mcp-proxy --headers Authorization 'Bearer YOUR_TOKEN' http://localhost:8080/sse\n"
+            "  mcp-proxy --sse-port 8080 -- your-command --arg1 value1 --arg2 value2\n"
+            "  mcp-proxy your-command --sse-port 8080 -e KEY VALUE -e ANOTHER_KEY ANOTHER_VALUE\n"
+            "  mcp-proxy your-command --sse-port 8080 --allow-origin='*'\n"
+        ),
+        formatter_class=argparse.RawTextHelpFormatter,
+    )
+    parser.add_argument(
+        "command_or_url",
+        help=(
+            "Command or URL to connect to. When a URL, will run an SSE client, "
+            "otherwise will run the given command and connect as a stdio client. "
+            "See corresponding options for more details."
+        ),
+        nargs="?",  # Required below to allow for coming form env var
+        default=SSE_URL,
+    )
+
+    sse_client_group = parser.add_argument_group("SSE client options")
+    sse_client_group.add_argument(
+        "-H",
+        "--headers",
+        nargs=2,
+        action="append",
+        metavar=("KEY", "VALUE"),
+        help="Headers to pass to the SSE server. Can be used multiple times.",
+        default=[],
+    )
+
+    stdio_client_options = parser.add_argument_group("stdio client options")
+    stdio_client_options.add_argument(
+        "args",
+        nargs="*",
+        help="Any extra arguments to the command to spawn the server",
+    )
+    stdio_client_options.add_argument(
+        "-e",
+        "--env",
+        nargs=2,
+        action="append",
+        metavar=("KEY", "VALUE"),
+        help="Environment variables used when spawning the server. Can be used multiple times.",
+        default=[],
+    )
+    stdio_client_options.add_argument(
+        "--pass-environment",
+        action=argparse.BooleanOptionalAction,
+        help="Pass through all environment variables when spawning the server.",
+        default=False,
+    )
+    stdio_client_options.add_argument(
+        "--debug",
+        action=argparse.BooleanOptionalAction,
+        help="Enable debug mode with detailed logging output.",
+        default=False,
+    )
+
+    sse_server_group = parser.add_argument_group("SSE server options")
+    sse_server_group.add_argument(
+        "--sse-port",
+        type=int,
+        default=0,
+        help="Port to expose an SSE server on. Default is a random port",
+    )
+    sse_server_group.add_argument(
+        "--sse-host",
+        default="127.0.0.1",
+        help="Host to expose an SSE server on. Default is 127.0.0.1",
+    )
+    sse_server_group.add_argument(
+        "--allow-origin",
+        nargs="+",
+        default=[],
+        help="Allowed origins for the SSE server. Can be used multiple times. Default is no CORS allowed.",  # noqa: E501
+    )
+
+    args = parser.parse_args()
+
+    if not args.command_or_url:
+        parser.print_help()
+        sys.exit(1)
+
+    logging.basicConfig(level=logging.DEBUG if args.debug else logging.INFO)
+    logger = logging.getLogger(__name__)
+
+    if (
+        SSE_URL
+        or args.command_or_url.startswith("http://")
+        or args.command_or_url.startswith("https://")
+    ):
+        # Start a client connected to the SSE server, and expose as a stdio server
+        logger.debug("Starting SSE client and stdio server")
+        headers = dict(args.headers)
+        if api_access_token := os.getenv("API_ACCESS_TOKEN", None):
+            headers["Authorization"] = f"Bearer {api_access_token}"
+        asyncio.run(run_sse_client(args.command_or_url, headers=headers))
+        return
+
+    # Start a client connected to the given command, and expose as an SSE server
+    logger.debug("Starting stdio client and SSE server")
+
+    # The environment variables passed to the server process
+    env: dict[str, str] = {}
+    # Pass through current environment variables if configured
+    if args.pass_environment:
+        env.update(os.environ)
+    # Pass in and override any environment variables with those passed on the command line
+    env.update(dict(args.env))
+
+    stdio_params = StdioServerParameters(
+        command=args.command_or_url,
+        args=args.args,
+        env=env,
+    )
+    sse_settings = SseServerSettings(
+        bind_host=args.sse_host,
+        port=args.sse_port,
+        allow_origins=args.allow_origin if len(args.allow_origin) > 0 else None,
+        log_level="DEBUG" if args.debug else "INFO",
+    )
+    asyncio.run(run_sse_server(stdio_params, sse_settings))
+
+
+if __name__ == "__main__":
+    main()

Service/mcp/mcp-proxy/project/entrypoint.sh

@@ -0,0 +1,27 @@
+#!/bin/bash
+
+app_env=${1:-development}
+
+source /home/devbox/project/.venv/bin/activate
+
+export PYTHONPATH=$PYTHONPATH:/home/devbox/project
+
+dev_commands() {
+    echo "Running development environment commands..."
+    cd /home/devbox/project && python -m project
+}
+
+prod_commands() {
+    echo "Running production environment commands..."
+    cd /home/devbox/project && python -m project
+}
+
+if [ "$app_env" = "production" ] || [ "$app_env" = "prod" ]; then
+    echo "Production environment detected"
+    prod_commands
+else
+    echo "Development environment detected"
+    dev_commands
+fi
+
+deactivate

Service/mcp/mcp-proxy/project/proxy_server.py

@@ -0,0 +1,128 @@
+"""Create an MCP server that proxies requests throgh an MCP client.
+
+This server is created independent of any transport mechanism.
+"""
+
+import logging
+import typing as t
+
+from mcp import server, types
+from mcp.client.session import ClientSession
+
+logger = logging.getLogger(__name__)
+
+
+async def create_proxy_server(remote_app: ClientSession) -> server.Server[object]:  # noqa: C901, PLR0915
+    """Create a server instance from a remote app."""
+    logger.debug("Sending initalization request to remote MCP server...")
+    response = await remote_app.initialize()
+    capabilities = response.capabilities
+
+    logger.debug("Configuring proxied MCP server...")
+    app: server.Server[object] = server.Server(name=response.serverInfo.name)
+
+    if capabilities.prompts:
+        logger.debug("Capabilities: adding Prompts...")
+
+        async def _list_prompts(_: t.Any) -> types.ServerResult:  # noqa: ANN401
+            result = await remote_app.list_prompts()
+            return types.ServerResult(result)
+
+        app.request_handlers[types.ListPromptsRequest] = _list_prompts
+
+        async def _get_prompt(req: types.GetPromptRequest) -> types.ServerResult:
+            result = await remote_app.get_prompt(req.params.name, req.params.arguments)
+            return types.ServerResult(result)
+
+        app.request_handlers[types.GetPromptRequest] = _get_prompt
+
+    if capabilities.resources:
+        logger.debug("Capabilities: adding Resources...")
+
+        async def _list_resources(_: t.Any) -> types.ServerResult:  # noqa: ANN401
+            result = await remote_app.list_resources()
+            return types.ServerResult(result)
+
+        app.request_handlers[types.ListResourcesRequest] = _list_resources
+
+        async def _list_resource_templates(_: t.Any) -> types.ServerResult:  # noqa: ANN401
+            result = await remote_app.list_resource_templates()
+            return types.ServerResult(result)
+
+        app.request_handlers[types.ListResourceTemplatesRequest] = _list_resource_templates
+
+        async def _read_resource(req: types.ReadResourceRequest) -> types.ServerResult:
+            result = await remote_app.read_resource(req.params.uri)
+            return types.ServerResult(result)
+
+        app.request_handlers[types.ReadResourceRequest] = _read_resource
+
+    if capabilities.logging:
+        logger.debug("Capabilities: adding Logging...")
+
+        async def _set_logging_level(req: types.SetLevelRequest) -> types.ServerResult:
+            await remote_app.set_logging_level(req.params.level)
+            return types.ServerResult(types.EmptyResult())
+
+        app.request_handlers[types.SetLevelRequest] = _set_logging_level
+
+    if capabilities.resources:
+        logger.debug("Capabilities: adding Resources...")
+
+        async def _subscribe_resource(req: types.SubscribeRequest) -> types.ServerResult:
+            await remote_app.subscribe_resource(req.params.uri)
+            return types.ServerResult(types.EmptyResult())
+
+        app.request_handlers[types.SubscribeRequest] = _subscribe_resource
+
+        async def _unsubscribe_resource(req: types.UnsubscribeRequest) -> types.ServerResult:
+            await remote_app.unsubscribe_resource(req.params.uri)
+            return types.ServerResult(types.EmptyResult())
+
+        app.request_handlers[types.UnsubscribeRequest] = _unsubscribe_resource
+
+    if capabilities.tools:
+        logger.debug("Capabilities: adding Tools...")
+
+        async def _list_tools(_: t.Any) -> types.ServerResult:  # noqa: ANN401
+            tools = await remote_app.list_tools()
+            return types.ServerResult(tools)
+
+        app.request_handlers[types.ListToolsRequest] = _list_tools
+
+        async def _call_tool(req: types.CallToolRequest) -> types.ServerResult:
+            try:
+                result = await remote_app.call_tool(
+                    req.params.name,
+                    (req.params.arguments or {}),
+                )
+                return types.ServerResult(result)
+            except Exception as e:  # noqa: BLE001
+                return types.ServerResult(
+                    types.CallToolResult(
+                        content=[types.TextContent(type="text", text=str(e))],
+                        isError=True,
+                    ),
+                )
+
+        app.request_handlers[types.CallToolRequest] = _call_tool
+
+    async def _send_progress_notification(req: types.ProgressNotification) -> None:
+        await remote_app.send_progress_notification(
+            req.params.progressToken,
+            req.params.progress,
+            req.params.total,
+        )
+
+    app.notification_handlers[types.ProgressNotification] = _send_progress_notification
+
+    async def _complete(req: types.CompleteRequest) -> types.ServerResult:
+        result = await remote_app.complete(
+            req.params.ref,
+            req.params.argument.model_dump(),
+        )
+        return types.ServerResult(result)
+
+    app.request_handlers[types.CompleteRequest] = _complete
+
+    return app