simplified mcp decorator

Author: hallvictoria

azure/functions/__init__.py

@@ -10,7 +10,7 @@
                          DecoratorApi, DataType, AuthLevel,
                          Cardinality, AccessRights, HttpMethod,
                          AsgiFunctionApp, WsgiFunctionApp,
-                         ExternalHttpFunctionApp, BlobSource)
+                         ExternalHttpFunctionApp, BlobSource, MCPToolContext)
 from ._durable_functions import OrchestrationContext, EntityContext
 from .decorators.function_app import (FunctionRegister, TriggerApi,
                                       BindingApi, SettingsApi)
@@ -99,7 +99,8 @@
     'Cardinality',
     'AccessRights',
     'HttpMethod',
-    'BlobSource'
+    'BlobSource',
+    'MCPToolContext'
 )
 
 __version__ = '1.25.0b1'

azure/functions/decorators/__init__.py

@@ -4,7 +4,7 @@
 from .function_app import FunctionApp, Function, DecoratorApi, DataType, \
     AuthLevel, Blueprint, ExternalHttpFunctionApp, AsgiFunctionApp, \
     WsgiFunctionApp, FunctionRegister, TriggerApi, BindingApi, \
-    SettingsApi, BlobSource
+    SettingsApi, BlobSource, MCPToolContext
 from .http import HttpMethod
 
 __all__ = [
@@ -24,5 +24,6 @@
     'Cardinality',
     'AccessRights',
     'HttpMethod',
-    'BlobSource'
+    'BlobSource',
+    'MCPToolContext'
 ]

azure/functions/decorators/function_app.py

@@ -2,6 +2,7 @@
 #  Licensed under the MIT License.
 import abc
 import asyncio
+import inspect
 import json
 import logging
 from abc import ABC
@@ -42,7 +43,7 @@
     AssistantQueryInput, AssistantPostInput, InputType, EmbeddingsInput, \
     semantic_search_system_prompt, \
     SemanticSearchInput, EmbeddingsStoreOutput
-from .mcp import MCPToolTrigger
+from .mcp import MCPToolTrigger, MCPToolContext, _TYPE_MAPPING, _extract_type_and_description
 from .retry_policy import RetryPolicy
 from .function_name import FunctionName
 from .warmup import WarmUpTrigger
@@ -462,6 +463,78 @@ def auth_level(self) -> AuthLevel:
 
 class TriggerApi(DecoratorApi, ABC):
     """Interface to extend for using existing trigger decorator functions."""
+    def mcp_tool(self) -> Callable[[Callable], Callable]:
+        """
+        Decorator to register an MCP tool function.
+
+        Automatically:
+        - Infers tool name from function name
+        - Extracts first line of docstring as description
+        - Extracts parameters and types for tool properties
+        - Handles MCPToolContext injection
+        """
+        def decorator(target_func: Callable) -> Callable:
+            sig = inspect.signature(target_func)
+            tool_name = target_func.__name__
+            description = (target_func.__doc__ or "").strip().split("\n")[0]
+
+            # Build tool properties metadata
+            tool_properties = []
+            for param_name, param in sig.parameters.items():
+                param_type_hint = param.annotation if param.annotation != inspect.Parameter.empty else str
+                actual_type, param_description = _extract_type_and_description(param_name, param_type_hint)
+                if actual_type is MCPToolContext:
+                    continue
+                property_type = _TYPE_MAPPING.get(actual_type, "string")
+                tool_properties.append({
+                    "propertyName": param_name,
+                    "propertyType": property_type,
+                    "description": param_description,
+                })
+
+            tool_properties_json = json.dumps(tool_properties)
+
+            # Wrapper function for MCP trigger
+            def wrapper(context: str) -> str:
+                try:
+                    content = json.loads(context)
+                    arguments = content.get("arguments", {})
+                    kwargs = {}
+
+                    for param_name, param in sig.parameters.items():
+                        param_type_hint = param.annotation if param.annotation != inspect.Parameter.empty else str
+                        actual_type, _ = _extract_type_and_description(param_name, param_type_hint)
+
+                        if actual_type is MCPToolContext:
+                            kwargs[param_name] = content
+                        elif param_name in arguments:
+                            kwargs[param_name] = arguments[param_name]
+                        else:
+                            return f"Error: Missing required parameter '{param_name}' for '{tool_name}'"
+
+                    result = target_func(**kwargs)
+                    return str(result)
+
+                except Exception as e:
+                    return f"Error executing function '{tool_name}': {str(e)}"
+
+            wrapper.__name__ = target_func.__name__
+            wrapper.__doc__ = target_func.__doc__
+
+            # Use the existing FunctionRegister mechanism to add the trigger
+            fb = self._configure_function_builder(lambda fb: fb)(wrapper)
+            fb.add_trigger(
+                trigger=MCPToolTrigger(
+                    name="context",
+                    tool_name=tool_name,
+                    description=description,
+                    tool_properties=tool_properties_json
+                )
+            )
+
+            return fb
+
+        return decorator
 
     def route(self,
               route: Optional[str] = None,

azure/functions/decorators/mcp.py

@@ -1,10 +1,18 @@
 from typing import Optional
+from typing import Any, Dict, Tuple, get_args, get_origin, Annotated
 
 from azure.functions.decorators.constants import (
     MCP_TOOL_TRIGGER
 )
 from azure.functions.decorators.core import Trigger, DataType
 
+# Mapping Python types to MCP property types
+_TYPE_MAPPING = {
+    int: "integer",
+    float: "number",
+    str: "string",
+    bool: "boolean",
+}
 
 class MCPToolTrigger(Trigger):
 
@@ -23,3 +31,18 @@ def __init__(self,
         self.description = description
         self.tool_properties = tool_properties
         super().__init__(name=name, data_type=data_type)
+
+# MCP-specific context object
+class MCPToolContext(Dict[str, Any]):
+    """Injected context object for MCP tool triggers."""
+    pass
+
+# Helper to extract actual type and description from Annotated types
+def _extract_type_and_description(param_name: str, type_hint: Any) -> Tuple[Any, str]:
+    if get_origin(type_hint) is Annotated:
+        args = get_args(type_hint)
+        actual_type = args[0]
+        # Use first string annotation as description if present
+        param_description = next((a for a in args[1:] if isinstance(a, str)), f"The {param_name} parameter.")
+        return actual_type, param_description
+    return type_hint, f"The {param_name} parameter."