@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import functools
 import json
 from collections.abc import Callable
 from pathlib import Path
@@ -15,6 +16,7 @@
 from pydantic import Field, ValidationInfo, validate_call
 
 from mcp.server.mcpserver.resources.base import Resource
+from mcp.server.mcpserver.utilities.context_injection import find_context_parameter, inject_context
 from mcp.shared._callable_inspection import is_async_callable
 from mcp.types import Annotations, Icon
 
@@ -52,18 +54,22 @@ class FunctionResource(Resource):
     - other types will be converted to JSON
     """
 
-    fn: Callable[[], Any] = Field(exclude=True)
+    fn: Callable[..., Any] = Field(exclude=True)
+    context_kwarg: str | None = Field(default=None, description="Name of the kwarg that should receive context")
 
-    async def read(self) -> str | bytes:
+    async def read(self, context: Any | None = None) -> str | bytes:
         """Read the resource by calling the wrapped function."""
         try:
+            kwargs = inject_context(self.fn, {}, context, self.context_kwarg)
             fn = self.fn
             if is_async_callable(fn):
-                result = await fn()
+                result = await fn(**kwargs)
             else:
-                result = await anyio.to_thread.run_sync(self.fn)
+                result = await anyio.to_thread.run_sync(functools.partial(self.fn, **kwargs))
 
-            if isinstance(result, Resource):  # pragma: no cover
+            if isinstance(result, FunctionResource):  # pragma: no cover
+                return await result.read(context)
+            elif isinstance(result, Resource):  # pragma: no cover
                 return await result.read()
             elif isinstance(result, bytes):
                 return result
@@ -86,12 +92,16 @@ def from_function(
         icons: list[Icon] | None = None,
         annotations: Annotations | None = None,
         meta: dict[str, Any] | None = None,
+        context_kwarg: str | None = None,
     ) -> FunctionResource:
         """Create a FunctionResource from a function."""
         func_name = name or fn.__name__
         if func_name == "<lambda>":  # pragma: no cover
             raise ValueError("You must provide a name for lambda functions")
 
+        if context_kwarg is None:
+            context_kwarg = find_context_parameter(fn)
+
         # ensure the arguments are properly cast
         fn = validate_call(fn)
 
@@ -102,6 +112,7 @@ def from_function(
             description=description or fn.__doc__ or "",
             mime_type=mime_type or "text/plain",
             fn=fn,
+            context_kwarg=context_kwarg,
             icons=icons,
             annotations=annotations,
             meta=meta,
 
@@ -451,7 +451,10 @@ async def read_resource(
             raise ResourceError(f"Unknown resource: {uri}") from exc
 
         try:
-            content = await resource.read()
+            if isinstance(resource, FunctionResource):
+                content = await resource.read(context)
+            else:
+                content = await resource.read()
             return [ReadResourceContents(content=content, mime_type=resource.mime_type, meta=resource.meta)]
         except Exception as exc:
             logger.exception(f"Error getting resource {uri}")
@@ -645,7 +648,7 @@ def resource(
         - other types will be converted to JSON
 
         If the URI contains parameters (e.g. "resource://{param}") or the function
-        has parameters, it will be registered as a template resource.
+        has non-Context parameters, it will be registered as a template resource.
 
         Args:
             uri: URI for the resource (e.g. "resource://my-resource" or "resource://{param}")
@@ -688,18 +691,14 @@ async def get_weather(city: str) -> str:
         def decorator(fn: _CallableT) -> _CallableT:
             # Check if this should be a template
             sig = inspect.signature(fn)
+            context_param = find_context_parameter(fn)
             has_uri_params = "{" in uri and "}" in uri
-            has_func_params = bool(sig.parameters)
+            func_params = {p for p in sig.parameters.keys() if p != context_param}
+            has_func_params = bool(func_params)
 
             if has_uri_params or has_func_params:
-                # Check for Context parameter to exclude from validation
-                context_param = find_context_parameter(fn)
-
                 # Validate that URI params match function params (excluding context)
                 uri_params = set(re.findall(r"{(\w+)}", uri))
-                # We need to remove the context_param from the resource function if
-                # there is any.
-                func_params = {p for p in sig.parameters.keys() if p != context_param}
 
                 if uri_params != func_params:
                     raise ValueError(
@@ -730,6 +729,7 @@ def decorator(fn: _CallableT) -> _CallableT:
                     icons=icons,
                     annotations=annotations,
                     meta=meta,
+                    context_kwarg=context_param,
                 )
                 self.add_resource(resource)
             return fn
 
@@ -820,6 +820,25 @@ def get_data() -> str:  # pragma: no cover
             assert resource.name == "test_get_data"
             assert resource.mime_type == "text/plain"
 
+    async def test_context_only_resource_registered_as_regular_resource(self):
+        mcp = MCPServer()
+
+        @mcp.resource("resource://user_profile")
+        def get_user_profile(ctx: Context) -> str:
+            assert ctx is not None
+            return "User profile"
+
+        resources = await mcp.list_resources()
+        templates = await mcp.list_resource_templates()
+        assert len(resources) == 1
+        assert resources[0].uri == "resource://user_profile"
+        assert templates == []
+
+        async with Client(mcp) as client:
+            result = await client.read_resource("resource://user_profile")
+            assert isinstance(result.contents[0], TextResourceContents)
+            assert result.contents[0].text == "User profile"
+
 
 class TestServerResourceTemplates:
     async def test_resource_with_params(self):