clarifai 11.4.2__tar.gz → 11.4.3rc1__tar.gz

{clarifai-11.4.2/clarifai.egg-info → clarifai-11.4.3rc1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: clarifai
-Version: 11.4.2
+Version: 11.4.3rc1
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai
 Author-email: support@clarifai.com
@@ -33,17 +33,6 @@ Requires-Dist: requests>=2.32.3
 Requires-Dist: aiohttp>=3.10.0
 Provides-Extra: all
 Requires-Dist: pycocotools>=2.0.7; extra == "all"
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license
-Dynamic: license-file
-Dynamic: provides-extra
-Dynamic: requires-dist
-Dynamic: requires-python
 
 <h1 align="center">
   <a href="https://www.clarifai.com/"><img alt="Clarifai" title="Clarifai" src="https://github.com/user-attachments/assets/623b883b-7fe5-4b95-bbfa-8691f5779af4"></a>

clarifai-11.4.3rc1/clarifai/__init__.py

@@ -0,0 +1 @@
+__version__ = "11.4.3rc1"

{clarifai-11.4.2 → clarifai-11.4.3rc1}/clarifai/cli/base.py

@@ -143,6 +143,14 @@ def dump(ctx_obj, output_format):
         json.dump(ctx_obj.to_dict(), sys.stdout, indent=2)
 
 
+@config.command(['cat'])
+@click.option('-o', '--output-format', default='yaml', type=click.Choice(['yaml', 'json']))
+@click.pass_obj
+def env(ctx_obj, output_format):
+    """Print env vars. Use: eval "$(clarifai config env)" """
+    ctx_obj.current.print_env_vars()
+
+
 @cli.command()
 @click.argument('api_url', default="https://api.clarifai.com")
 @click.option('--user_id', required=False, help='User ID')

{clarifai-11.4.2 → clarifai-11.4.3rc1}/clarifai/cli/model.py

@@ -504,6 +504,10 @@ def local_dev(ctx, model_path):
 
     logger.info(f"Current deployment_id: {deployment_id}")
 
+    logger.info(
+        f"Full url for the model: /users/{user_id}/apps/{app_id}/models/{model.id}/versions/{version.id}"
+    )
+
     # Now that we have all the context in ctx.obj, we need to update the config.yaml in
     # the model_path directory with the model object containing user_id, app_id, model_id, version_id
     config_file = os.path.join(model_path, 'config.yaml')
@@ -526,13 +530,9 @@ def local_dev(ctx, model_path):
         ModelBuilder._backup_config(config_file)
         ModelBuilder._save_config(config_file, config)
 
-    # client_model = Model(
-    # TODO: once we can generate_client_script from ModelBuilder or similar
-    # we should be able to put the exact function call in place.
-    # model_script = model.generate_client_script()
-
     builder = ModelBuilder(model_path, download_validation_only=True)
-    method_signatures = builder.get_method_signatures()
+    # don't mock for local dev since you need the dependencies to run the code anyways.
+    method_signatures = builder.get_method_signatures(mocking=False)
 
     from clarifai.runners.utils import code_script
 

clarifai-11.4.3rc1/clarifai/runners/models/example_mcp_server.py

@@ -0,0 +1,44 @@
+"""Example of how to create an MCP server using MCPClass."""
+
+from typing import Dict
+from fastmcp import Tool
+
+from clarifai.runners.models.mcp_class import MCPClass
+
+
+class ExampleMCPServer(MCPClass):
+    """Example MCP server that provides a simple calculator tool."""
+
+    def __init__(self):
+        super().__init__()
+        
+        # Define and register a calculator tool
+        calculator_tool = Tool(
+            name="calculator",
+            description="A simple calculator that can add two numbers",
+            parameters={
+                "type": "object",
+                "properties": {
+                    "a": {"type": "number", "description": "First number"},
+                    "b": {"type": "number", "description": "Second number"}
+                },
+                "required": ["a", "b"]
+            }
+        )
+        
+        @calculator_tool
+        async def add(params: Dict[str, float]) -> float:
+            """Add two numbers together."""
+            return params["a"] + params["b"]
+
+        # Register the tool with the MCP server
+        self.add_tool(calculator_tool)
+
+
+# Usage example:
+if __name__ == "__main__":
+    # Create and run the server
+    server = ExampleMCPServer()
+    
+    # The server is now ready to handle MCP requests through the mcp_transport method
+    # For example, a client could send a request to list tools or call the calculator

clarifai-11.4.3rc1/clarifai/runners/models/mcp_class.py

@@ -0,0 +1,143 @@
+"""Base class for creating Model Context Protocol (MCP) servers."""
+
+import asyncio
+import json
+from typing import Any
+
+from fastmcp import Client, FastMCP  # use fastmcp v2 not the built in mcp
+from mcp import types
+from mcp.shared.exceptions import McpError
+
+from clarifai.runners.models.model_class import ModelClass
+
+# class MCPServerProvider(abc.ABC):
+#     """
+#     Base class for creating Model Context Protocol (MCP) servers.
+
+#     This class provides a base implementation of the MCP server, including
+#     methods for handling requests and responses, as well as error handling and
+#     logging.
+
+#     Attributes:
+#     _server: The FastMCP server instance.
+#     _tools: List of tools available in the server.
+#     _resources: List of resources available in the server.
+#     _prompts: List of prompts available in the server.
+
+#     Methods:
+#     get_server(): Returns the FastMCP server instance.
+#     mcp_transport(msg): Handles incoming messages and sends them to the FastMCP server.
+#     """
+
+#     @abc.abstractmethod
+#     def get_server(self) -> FastMCP:
+#         """Required method for each subclass to implement to return the FastMCP server to use."""
+#         if self._server is None:
+#             raise ValueError("Server not initialized")
+#         return self._server
+
+
+class MCPModelClass(ModelClass):
+    """Base class for wrapping FastMCP servers as a model running in Clarfai. This handles
+    all the transport between the API and the MCP server here. Simply subclass this and implement
+    the get_server() method to return the FastMCP server instance. The server is then used to
+    handle all the requests and responses.
+    """
+
+    def load_model(self):
+        # in memory transport provided in fastmcp v2 so we can easily use the client functions.
+        self.client = Client(self.get_server())
+
+    def get_server(self) -> FastMCP:
+        """Required method for each subclass to implement to return the FastMCP server to use."""
+        raise NotImplementedError("Subclasses must implement get_server() method")
+
+    @ModelClass.method
+    def mcp_transport(self, msg: str) -> str:
+        """The single model method to get the jsonrpc message and send it to the FastMCP server then
+        return it's response.
+
+        """
+
+        async def send_notification(client_message: types.ClientNotification) -> None:
+            async with self.client:
+                # Strip the jsonrpc field since send_notification will also pass it in for some reason.
+                client_message = types.ClientNotification.model_validate(
+                    client_message.model_dump(
+                        by_alias=True, mode="json", exclude_none=True, exclude={"jsonrpc"}
+                    )
+                )
+                try:
+                    return await self.client.session.send_notification(client_message)
+                except McpError as e:
+                    return types.JSONRPCError(jsonrpc="2.0", error=e.error)
+
+        async def send_request(client_message: types.ClientRequest, id: str) -> Any:
+            async with self.client:
+                # Strip the jsonrpc and id fields as send_request sets them again too.
+                client_message = types.ClientRequest.model_validate(
+                    client_message.model_dump(
+                        by_alias=True, mode="json", exclude_none=True, exclude={"jsonrpc", "id"}
+                    )
+                )
+
+                result_type = None
+                print("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")
+                print(types.PingRequest)
+                if isinstance(client_message.root, types.PingRequest):
+                    result_type = types.EmptyResult
+                elif isinstance(client_message.root, types.InitializeRequest):
+                    return await self.client.session.initialize()
+                elif isinstance(client_message.root, types.SetLevelRequest):
+                    result_type = types.EmptyResult
+                elif isinstance(client_message.root, types.ListResourcesRequest):
+                    result_type = types.ListResourcesResult
+                elif isinstance(client_message.root, types.ListResourceTemplatesRequest):
+                    result_type = types.ListResourceTemplatesResult
+                elif isinstance(client_message.root, types.ReadResourceRequest):
+                    result_type = types.ReadResourceResult
+                elif isinstance(client_message.root, types.SubscribeRequest):
+                    result_type = types.EmptyResult
+                elif isinstance(client_message.root, types.UnsubscribeRequest):
+                    result_type = types.EmptyResult
+                elif isinstance(client_message.root, types.ListPromptsRequest):
+                    result_type = types.ListPromptsResult
+                elif isinstance(client_message.root, types.GetPromptRequest):
+                    result_type = types.GetPromptResult
+                elif isinstance(client_message.root, types.CompleteRequest):
+                    result_type = types.CompleteResult
+                elif isinstance(client_message.root, types.ListToolsRequest):
+                    result_type = types.ListToolsResult
+                elif isinstance(client_message.root, types.CallToolRequest):
+                    result_type = types.CallToolResult
+                else:
+                    # this is a special case where we need to return the list of tools.
+                    raise NotImplementedError(f"Method {client_message.method} not implemented")
+                # Call the mcp server using send_request() or send_notification() depending on the method.
+                try:
+                    return await self.client.session.send_request(client_message, result_type)
+                except McpError as e:
+                    return types.JSONRPCError(jsonrpc="2.0", id=id, error=e.error)
+
+        # The message coming here is the generic request. We look at it's .method
+        # to determine which client function to call and to further subparse the params.
+        # Note(zeiler): unfortunately the pydantic types in mcp/types.py are not consistent.
+        # The JSONRPCRequest are supposed to have an id but the InitializeRequest
+        # does not have it.
+        d = json.loads(msg)
+
+        # If we have an id it's a JSONRPCRequest
+        if not d.get('method', None).startswith("notifications/"):
+            # rpc_message2 = types.JSONRPCRequest.model_validate(rpc_message)
+            # underlying: types.JSONRPCRequest = rpc_message.root
+            client_message = types.ClientRequest.model_validate(d)
+            response = asyncio.run(
+                send_request(client_message, id=d.get('id', ""))
+            )  # underlying.id))
+        else:  # JSONRPCRequest
+            client_message = types.ClientNotification.model_validate(d)
+            response = asyncio.run(send_notification(client_message))
+        if response is None:
+            return ""
+        # return as a serialized json string
+        return response.model_dump_json(by_alias=True, exclude_none=True)

clarifai-11.4.3rc1/clarifai/runners/models/mcp_class.py~

@@ -0,0 +1,149 @@
+"""Base class for creating Model Context Protocol (MCP) servers."""
+
+import asyncio
+import json
+from typing import Any
+
+from fastmcp import Client, FastMCP  # use fastmcp v2 not the built in mcp
+from mcp import types
+from mcp.shared.exceptions import McpError
+
+from clarifai.runners.models.model_class import ModelClass
+
+# class MCPServerProvider(abc.ABC):
+#     """
+#     Base class for creating Model Context Protocol (MCP) servers.
+
+#     This class provides a base implementation of the MCP server, including
+#     methods for handling requests and responses, as well as error handling and
+#     logging.
+
+#     Attributes:
+#     _server: The FastMCP server instance.
+#     _tools: List of tools available in the server.
+#     _resources: List of resources available in the server.
+#     _prompts: List of prompts available in the server.
+
+#     Methods:
+#     get_server(): Returns the FastMCP server instance.
+#     mcp_transport(msg): Handles incoming messages and sends them to the FastMCP server.
+#     """
+
+#     @abc.abstractmethod
+#     def get_server(self) -> FastMCP:
+#         """Required method for each subclass to implement to return the FastMCP server to use."""
+#         if self._server is None:
+#             raise ValueError("Server not initialized")
+#         return self._server
+
+
+class MCPModelClass(ModelClass, MCPServerProvider):
+    """Base class for wrapping FastMCP servers as a model running in Clarfai. This handles
+    all the transport between the API and the MCP server here. Simply subclass this and implement
+    the get_server() method to return the FastMCP server instance. The server is then used to
+    handle all the requests and responses.
+    """
+
+    def load_model(self):
+        # in memory transport provided in fastmcp v2 so we can easily use the client functions.
+        self.client = Client(self.get_server())
+
+    def get_server(self) -> FastMCP:
+        """Required method for each subclass to implement to return the FastMCP server to use."""
+        if self._server is None:
+            raise ValueError("Server not initialized")
+        return self._server
+
+    @ModelClass.method
+    def mcp_transport(self, msg: str) -> str:
+        """The single model method to get the jsonrpc message and send it to the FastMCP server then
+        return it's response.
+
+        Arguments:
+          msg: The incoming message to be handled in serialized JSONRPC format from an MCP client.
+        Returns:
+          str: The response to the incoming message in serialized JSONRPC format
+        """
+
+        async def send_notification(client_message: types.ClientNotification) -> None:
+            async with self.client:
+                # Strip the jsonrpc field since send_notification will also pass it in for some reason.
+                client_message = types.ClientNotification.model_validate(
+                    client_message.model_dump(
+                        by_alias=True, mode="json", exclude_none=True, exclude={"jsonrpc"}
+                    )
+                )
+                try:
+                    return await self.client.session.send_notification(client_message)
+                except McpError as e:
+                    return types.JSONRPCError(jsonrpc="2.0", error=e.error)
+
+        async def send_request(client_message: types.ClientRequest, id: str) -> Any:
+            async with self.client:
+                # Strip the jsonrpc and id fields as send_request sets them again too.
+                client_message = types.ClientRequest.model_validate(
+                    client_message.model_dump(
+                        by_alias=True, mode="json", exclude_none=True, exclude={"jsonrpc", "id"}
+                    )
+                )
+
+                result_type = None
+                print("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")
+                print(types.PingRequest)
+                if isinstance(client_message.root, types.PingRequest):
+                    result_type = types.EmptyResult
+                elif isinstance(client_message.root, types.InitializeRequest):
+                    return await self.client.session.initialize()
+                elif isinstance(client_message.root, types.SetLevelRequest):
+                    result_type = types.EmptyResult
+                elif isinstance(client_message.root, types.ListResourcesRequest):
+                    result_type = types.ListResourcesResult
+                elif isinstance(client_message.root, types.ListResourceTemplatesRequest):
+                    result_type = types.ListResourceTemplatesResult
+                elif isinstance(client_message.root, types.ReadResourceRequest):
+                    result_type = types.ReadResourceResult
+                elif isinstance(client_message.root, types.SubscribeRequest):
+                    result_type = types.EmptyResult
+                elif isinstance(client_message.root, types.UnsubscribeRequest):
+                    result_type = types.EmptyResult
+                elif isinstance(client_message.root, types.ListPromptsRequest):
+                    result_type = types.ListPromptsResult
+                elif isinstance(client_message.root, types.GetPromptRequest):
+                    result_type = types.GetPromptResult
+                elif isinstance(client_message.root, types.CompleteRequest):
+                    result_type = types.CompleteResult
+                elif isinstance(client_message.root, types.ListToolsRequest):
+                    result_type = types.ListToolsResult
+                elif isinstance(client_message.root, types.CallToolRequest):
+                    result_type = types.CallToolResult
+                else:
+                    # this is a special case where we need to return the list of tools.
+                    raise NotImplementedError(f"Method {client_message.method} not implemented")
+                # Call the mcp server using send_request() or send_notification() depending on the method.
+                try:
+                    return await self.client.session.send_request(client_message, result_type)
+                except McpError as e:
+                    return types.JSONRPCError(jsonrpc="2.0", id=id, error=e.error)
+
+        # The message coming here is the generic request. We look at it's .method
+        # to determine which client function to call and to further subparse the params.
+        # Note(zeiler): unfortunately the pydantic types in mcp/types.py are not consistent.
+        # The JSONRPCRequest are supposed to have an id but the InitializeRequest
+        # does not have it.
+        d = json.loads(msg)
+
+        # If we have an id it's a JSONRPCRequest
+        if not d.get('method', None).startswith("notifications/"):
+            # rpc_message2 = types.JSONRPCRequest.model_validate(rpc_message)
+            # underlying: types.JSONRPCRequest = rpc_message.root
+            client_message = types.ClientRequest.model_validate(d)
+            response = asyncio.run(
+                send_request(client_message, id=d.get('id', ""))
+            )  # underlying.id))
+        else:  # JSONRPCRequest
+            client_message = types.ClientNotification.model_validate(d)
+            response = asyncio.run(send_notification(client_message))
+        if response is None:
+            return ""
+        # return as a serialized json string
+        return response.model_dump_json(by_alias=True, exclude_none=True)