simplify gradio

Dockerfile

@@ -1,12 +0,0 @@
-FROM python:3.10
-
-RUN useradd -m -u 1000 user
-USER user
-ENV PATH="/home/user/.local/bin:$PATH"
-
-WORKDIR /app
-
-RUN pip install --no-cache-dir --upgrade mcp fastapi
-
-COPY --chown=user . /app
-CMD ["python", "app.py"]

README.md

@@ -3,7 +3,7 @@ title: Counter
 emoji: 🏆
 colorFrom: green
 colorTo: indigo
-sdk: docker
+sdk: gradio
 app_file: app.py
 pinned: false
 ---

app.py

@@ -1,44 +1,18 @@
-from collections.abc import AsyncIterator
-from contextlib import asynccontextmanager
-from dataclasses import dataclass
+import gradio as gr
 
-from mcp.server.fastmcp import Context, FastMCP
-from mcp.server.session import ServerSession
-
-
-class CounterEnv:
-    _counter = 0
-
-    @classmethod
-    async def connect(cls) -> "CounterEnv":
-        return cls()
+class Counter:
+    def reset(self) -> str:
+        self.value = 0
+        return "Counter reset to 0"
 
     def step(self) -> str:
-        self._counter += 1
-        return f"Step result {self._counter}"
-
-    async def close(self) -> None:
-        pass
-
-@dataclass
-class AppContext:
-    env: CounterEnv
-
-
-@asynccontextmanager
-async def app_lifespan(server: FastMCP) -> AsyncIterator[AppContext]:
-    env = await CounterEnv.connect()
-    try:
-        yield AppContext(env=env)
-    finally:
-        await env.close()
+        self.value += 1
+        return f"Counter is at {self.value}"
 
-mcp = FastMCP("My App", lifespan=app_lifespan)
+counter = Counter()
 
-@mcp.tool()
-def step(ctx: Context[ServerSession, AppContext]) -> str:
-    env = ctx.request_context.lifespan_context.env
-    return env.step()
+with gr.Blocks() as demo:
+    gr.api(counter.reset, api_name="/reset")
+    gr.api(counter.step, api_name="/step")
 
-if __name__ == "__main__":
-    mcp.run('streamable-http')
+demo.launch(mcp_server=True)

my_lib.py

@@ -1,62 +0,0 @@
-from abc import ABC, abstractmethod
-from contextlib import asynccontextmanager
-from dataclasses import dataclass
-from collections.abc import AsyncIterator
-from mcp.server.fastmcp import Context, FastMCP
-from mcp.server.session import ServerSession
-
-class Environment(ABC):
-    """Simple synchronous interface for environments."""
-
-    async def connect(self) -> "Environment":
-        """
-        Optional async setup.  
-        Defaults to returning self if no connection is needed.
-        """
-        return self
-
-    async def close(self) -> None:
-        """Optional async cleanup."""
-        return
-
-    @abstractmethod
-    def reset(self) -> str:
-        """Reset the environment and return an initial state."""
-        ...
-
-    @abstractmethod
-    def step(self) -> str:
-        """Take one step and return a result."""
-        ...
-
-
-
-@dataclass
-class _EnvCtx:
-    env: Environment
-
-def create_mcp_app(name: str, env_cls: type[Environment]) -> FastMCP:
-    """
-    Build a FastMCP app around an Environment subclass.
-    Handles async lifecycle automatically.
-    """
-
-    @asynccontextmanager
-    async def lifespan(server: FastMCP) -> AsyncIterator[_EnvCtx]:
-        env = await env_cls().connect()
-        try:
-            yield _EnvCtx(env)
-        finally:
-            await env.close()
-
-    mcp = FastMCP(name, lifespan=lifespan)
-
-    @mcp.tool()
-    def reset(ctx: Context[ServerSession, _EnvCtx]) -> str:
-        return ctx.request_context.lifespan_context.env.reset()
-
-    @mcp.tool()
-    def step(ctx: Context[ServerSession, _EnvCtx]) -> str:
-        return ctx.request_context.lifespan_context.env.step()
-
-    return mcp