mseep-lightfast-mcp 0.0.1__py3-none-any.whl

lightfast_mcp/servers/mock/tools.py

@@ -0,0 +1,161 @@
+"""
+Tool functions for the Mock MCP server.
+
+These functions implement the actual tools that can be called via the MCP protocol.
+"""
+
+import asyncio
+import json
+import time
+from typing import Any
+
+from fastmcp import Context
+
+from ...utils.logging_utils import get_logger
+
+logger = get_logger("MockTools")
+
+# Global reference to current server instance for tools to access configuration
+_current_server = None
+
+
+def set_current_server(server):
+    """Set the current server instance for tools to access."""
+    global _current_server
+    _current_server = server
+
+
+async def get_server_status(ctx: Context) -> dict[str, Any]:
+    """
+    Get the current status of the mock MCP server.
+    """
+    logger.info("Received request for server status.")
+    await asyncio.sleep(0.1)  # Simulate a very small delay
+
+    if _current_server and hasattr(_current_server, "mcp") and _current_server.mcp:
+        server_name = _current_server.mcp.name
+        config_name = _current_server.config.name
+        description = _current_server.config.description
+        version = _current_server.SERVER_VERSION
+        server_info = getattr(_current_server, "info", None)
+        tools_count = len(
+            server_info.tools if server_info and hasattr(server_info, "tools") else []
+        )
+    else:
+        # Fallback for testing
+        server_name = "test-mock"
+        config_name = "test-mock"
+        description = "Mock MCP Server for testing"
+        version = "1.0.0"
+        tools_count = 3
+
+    return {
+        "status": "running",
+        "server_name": server_name,
+        "config_name": config_name,
+        "server_type": "mock",
+        "version": version,
+        "description": description,
+        "timestamp": time.time(),
+        "tools_available": tools_count,
+        "uptime_seconds": time.time()
+        - getattr(_current_server, "_start_time", time.time())
+        if _current_server
+        else 0,
+    }
+
+
+async def fetch_mock_data(
+    ctx: Context, data_id: str, delay_seconds: float | None = None
+) -> dict[str, Any]:
+    """
+    Fetches mock data associated with a given ID after a specified delay.
+
+    Parameters:
+    - data_id: The identifier for the mock data to fetch.
+    - delay_seconds: The time in seconds to wait before returning the data.
+    """
+    default_delay = 0.5
+    if _current_server and hasattr(_current_server, "default_delay"):
+        default_delay = _current_server.default_delay
+
+    if delay_seconds is None:
+        delay_seconds = default_delay
+
+    logger.info(
+        f"Received request to fetch mock data for id: '{data_id}' with delay: {delay_seconds}s."
+    )
+    await asyncio.sleep(delay_seconds)
+
+    server_name = "mock-server"
+    if _current_server and hasattr(_current_server, "config"):
+        server_name = _current_server.config.name
+
+    mock_data = {
+        "id": data_id,
+        "content": f"This is mock content for {data_id}.",
+        "details": {
+            "field1": "value1",
+            "field2": 123,
+            "is_mock": True,
+            "server_name": server_name,
+        },
+        "retrieved_at": time.time(),
+        "delay_used": delay_seconds,
+    }
+
+    logger.info(f"Returning mock data for id: '{data_id}'.")
+    return mock_data
+
+
+async def execute_mock_action(
+    ctx: Context,
+    action_name: str,
+    parameters: dict[str, Any] | None = None,
+    delay_seconds: float | None = None,
+) -> dict[str, Any]:
+    """
+    Simulates the execution of an action with given parameters after a specified delay.
+
+    Parameters:
+    - action_name: The name of the mock action to execute.
+    - parameters: A dictionary of parameters for the action.
+    - delay_seconds: The time in seconds to wait before returning the action result.
+    """
+    if parameters is None:
+        parameters = {}
+
+    default_delay = 0.5
+    if _current_server and hasattr(_current_server, "default_delay"):
+        default_delay = _current_server.default_delay
+
+    if delay_seconds is None:
+        delay_seconds = default_delay
+
+    logger.info(
+        f"Received request to execute mock action: '{action_name}' with params: "
+        f"{json.dumps(parameters)} and delay: {delay_seconds}s."
+    )
+
+    await asyncio.sleep(delay_seconds)
+
+    server_name = "mock-server"
+    if _current_server and hasattr(_current_server, "config"):
+        server_name = _current_server.config.name
+
+    result = {
+        "action_name": action_name,
+        "status": "completed_mock",
+        "parameters_received": parameters,
+        "message": f"Mock action '{action_name}' executed successfully on {server_name}.",
+        "completed_at": time.time(),
+        "delay_used": delay_seconds,
+        "server_info": {
+            "name": server_name,
+            "type": "mock",
+            "version": "1.0.0",
+        },
+    }
+
+    logger.info(f"Returning result for mock action: '{action_name}'.")
+    return result

lightfast_mcp/servers/mock_server.py

@@ -0,0 +1,78 @@
+"""
+Mock MCP server using the new modular architecture.
+This is now the clean entry point for the Mock server.
+"""
+
+import json
+import os
+
+from ..core.base_server import ServerConfig
+from ..utils.logging_utils import configure_logging, get_logger
+from .mock.server import MockMCPServer
+
+# Configure logging
+configure_logging(level="INFO")
+logger = get_logger("MockMCP")
+
+SERVER_NAME = "MockMCP"
+
+
+def main():
+    """Run the Mock MCP server."""
+    logger.info("Starting Mock MCP server")
+
+    # Check for environment configuration (from ServerOrchestrator)
+    env_config = os.getenv("LIGHTFAST_MCP_SERVER_CONFIG")
+
+    if env_config:
+        try:
+            # Parse configuration from environment
+            config_data = json.loads(env_config)
+            config = ServerConfig(
+                name=config_data.get("name", SERVER_NAME),
+                description=config_data.get(
+                    "description", "Mock MCP Server for testing and development"
+                ),
+                host=config_data.get("host", "localhost"),
+                port=config_data.get("port", 8000),
+                transport=config_data.get(
+                    "transport", "streamable-http"
+                ),  # Default to HTTP for subprocess
+                path=config_data.get("path", "/mcp"),
+                config=config_data.get(
+                    "config", {"type": "mock", "delay_seconds": 0.5}
+                ),
+            )
+            logger.info(
+                f"Using environment configuration: {config.transport}://{config.host}:{config.port}"
+            )
+        except (json.JSONDecodeError, KeyError) as e:
+            logger.warning(f"Invalid environment configuration: {e}, using defaults")
+            config = _get_default_config()
+    else:
+        # Use default configuration for standalone running
+        config = _get_default_config()
+
+    # Create and run server
+    server = MockMCPServer(config)
+    server.run()
+
+
+def _get_default_config() -> ServerConfig:
+    """Get default configuration for standalone running."""
+    return ServerConfig(
+        name=SERVER_NAME,
+        description="Mock MCP Server for testing and development",
+        host="localhost",
+        port=8002,  # Use port 8002 by default for mock server
+        transport="streamable-http",  # Use HTTP by default for easier testing
+        path="/mcp",
+        config={
+            "type": "mock",
+            "delay_seconds": 0.5,
+        },
+    )
+
+
+if __name__ == "__main__":
+    main()

lightfast_mcp/utils/__init__.py

@@ -0,0 +1 @@
+# This file makes 'utils' a Python package.

lightfast_mcp/utils/logging_utils.py

@@ -0,0 +1,69 @@
+"""Logging utilities for FastMCP."""
+
+import logging
+from typing import Literal
+
+from rich.console import Console
+from rich.logging import RichHandler
+
+
+def get_logger(name: str) -> logging.Logger:
+    """Get a logger nested under FastMCP namespace.
+
+    Args:
+        name: the name of the logger, which will be prefixed with 'FastMCP.'
+
+    Returns:
+        a configured logger instance
+    """
+    return logging.getLogger(f"FastMCP.{name}")
+
+
+def configure_logging(
+    level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] | int = "INFO",
+    logger: logging.Logger | None = None,
+) -> None:
+    """
+    Configure logging for FastMCP.
+
+    Args:
+        logger: the logger to configure
+        level: the log level to use
+    """
+    if logger is None:
+        # If no specific logger is passed, configure the root "FastMCP" logger.
+        # Child loggers created with get_logger() will inherit this configuration.
+        logger = logging.getLogger("FastMCP")
+
+    # Set the level for the logger we are configuring.
+    # This ensures that even if child loggers are created before this call,
+    # they will respect this base level if they don't override it.
+    logger.setLevel(level)
+
+    # Configure the handler specifically for the logger instance being passed or the root "FastMCP" logger.
+    # Avoid adding handlers to the root logger of Python's logging system unless intended.
+    handler = RichHandler(
+        console=Console(stderr=True), rich_tracebacks=True, show_path=False
+    )
+    # Using a simple formatter as RichHandler does most of the styling.
+    # The default RichHandler format is "%(message)s" and it includes time and level.
+    # formatter = logging.Formatter("%(message)s")
+    # handler.setFormatter(formatter) # Not strictly necessary if RichHandler default is fine
+
+    # Remove any existing handlers from THIS logger to avoid duplicates on reconfiguration.
+    # This is important if configure_logging can be called multiple times.
+    for hdlr in logger.handlers[:]:
+        logger.removeHandler(hdlr)
+
+    logger.addHandler(handler)
+
+    # Ensure that messages propagate up to the root "FastMCP" logger if this is a child logger.
+    # And ensure the root "FastMCP" logger doesn't propagate to Python's root logger
+    # if we only want RichHandler on "FastMCP" namespace.
+    if logger.name != "FastMCP":
+        logger.propagate = True  # Default, but good to be aware of
+    else:
+        # For the root "FastMCP" logger, decide if it should propagate to Python's root.
+        # If Python's root has handlers (e.g. from basicConfig elsewhere), you might get duplicates.
+        # Setting propagate to False for "FastMCP" means only RichHandler will handle its logs.
+        logger.propagate = False

mseep_lightfast_mcp-0.0.1.dist-info/METADATA

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: mseep-lightfast-mcp
+Version: 0.0.1
+Summary: MCP server implementations for creative applications (Blender, etc.)
+Author-email: mseep <support@skydeck.ai>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/lightfastai/lightfast-mcp
+Project-URL: Bug Tracker, https://github.com/lightfastai/lightfast-mcp/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/plain
+License-File: LICENSE
+Requires-Dist: fastmcp>=2.0.0
+Requires-Dist: rich
+Requires-Dist: pyyaml
+Requires-Dist: anthropic
+Requires-Dist: openai
+Requires-Dist: typer
+Provides-Extra: dev
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: taskipy; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: coverage; extra == "dev"
+Requires-Dist: nox; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Dynamic: license-file
+
+Package managed by MseeP.ai

mseep_lightfast_mcp-0.0.1.dist-info/RECORD

@@ -0,0 +1,43 @@
+common/__init__.py,sha256=wN-w27w5gXHXkHfVgShEKyJhMWVukCi2AeQa5j_QksA,372
+common/types.py,sha256=HbSRCUMd5Red-XXdNzxaNqgC66PBiJySxnzpyelN8uw,4992
+lightfast_mcp/__init__.py,sha256=QLNMWnqqLjuwtZy82RNZX0Kz-lxR2xtuxwzmYPZ1wws,1439
+lightfast_mcp/exceptions.py,sha256=Ylq6umzYIxc4fqlpOBNcR9X76Jpc20IQP36e_8qjHjo,1274
+lightfast_mcp/core/__init__.py,sha256=9uyaKzqPD_MkH_EYHTrZuC9g7iwGfqDl99iZ4NNGvMs,318
+lightfast_mcp/core/base_server.py,sha256=O-DUgkcgvZgn4j67jyM7cX2NUGn0lEvkmprIHMhFR4U,7078
+lightfast_mcp/servers/__init__.py,sha256=m8uQ9HUARdYcDupHSjscj_El8G_juzFDZXY5RmNO-pU,60
+lightfast_mcp/servers/blender_mcp_server.py,sha256=v-94S9TGKME3HZatAfXjhoaDG-1FMVLMWzw5owGr8EE,2707
+lightfast_mcp/servers/mock_server.py,sha256=G-1FYQjOsppy06hJHTgMcL2BpEeJ02CXKXpfbqK9IxY,2501
+lightfast_mcp/servers/blender/__init__.py,sha256=XinY6nr6bsb5fHsfKZ4YhtNdtcoORXy8nnbUFbdMDUc,103
+lightfast_mcp/servers/blender/server.py,sha256=QVP3kPvvdmw3Gg0cPYTg5RdC5mQLqy7_55_38bHvfvk,12099
+lightfast_mcp/servers/mock/__init__.py,sha256=4huBgNiQrN3_aV6d3MZqeVE9A1WQBwURmswJC7cdBZ0,94
+lightfast_mcp/servers/mock/server.py,sha256=zMxcClTfhi3hckvpHSOf_cTl6aSTrEC9qaQkIpmMgOQ,3271
+lightfast_mcp/servers/mock/tools.py,sha256=1obQXq4KH3jQ1va7t14TExV0xXrusfCuH-pyDqnR0TA,4884
+lightfast_mcp/utils/__init__.py,sha256=X1MkpWIRxOfTQVma5j7cKftMcy3e5sr7bccoE0vb91c,44
+lightfast_mcp/utils/logging_utils.py,sha256=BX4gQ-foeJ71JaFUMt1MyAf76MleCnlWI3WMDrJGOf4,2756
+mseep_lightfast_mcp-0.0.1.dist-info/licenses/LICENSE,sha256=F4vfMqNpXJNbT7M7GjiaPKktILSa7MzDQ9kB46jqpP4,1066
+tools/__init__.py,sha256=KzA5Q-K5TyC2ZvTIumQuTlcBf4bvyuJfEICGZnTRwPw,1189
+tools/ai/__init__.py,sha256=31XxLKEg-h69xz_sKqt3Yo_X7ijrtBJQjL4L5blmSVY,214
+tools/ai/conversation_cli.py,sha256=AFXbaTewrhX6r7PtqBscMlYmkfWx7ozBLn-CLZVV7LQ,11674
+tools/ai/conversation_client.py,sha256=tRxfs_Xpy0N63EZ_vyHSqV26jt-O0aTIzovXnek5tuo,14904
+tools/ai/conversation_session.py,sha256=JcOUX-dxbKhtCuUXjCB9LZZMHwXbQY7zFj5a9cKomck,12372
+tools/ai/tool_executor.py,sha256=Hn_yGgliVt-YCHNfVTX6ECmdGVhFmV18RNSfJXUp7po,9291
+tools/ai/providers/__init__.py,sha256=vuU7vcV8vcSiMGDpg8HRjaRGBUtKOpH_JTbghhKrQUg,270
+tools/ai/providers/base_provider.py,sha256=h3ANMzLZjdEEOqxHI2mgP447GUa4OYvWZcEShv43a5E,1774
+tools/ai/providers/claude_provider.py,sha256=ruLRLDVNpdcUz7VRiKZdDdaEATe0ZOkCzAzR6ihHpvY,7510
+tools/ai/providers/openai_provider.py,sha256=0izmr3dcTWUW5BnTqxNZkA72dWWUDhqM_lH5k4qZrE4,7394
+tools/common/__init__.py,sha256=yOHjgLvPK_Yx10TQp79jVPyB84YJCFjH7zhYSpR33ig,2079
+tools/common/async_utils.py,sha256=WT43Lw9hOEuNbRzRwGZV1jQppnYpdKa-DD4NM5KdweA,15520
+tools/common/errors.py,sha256=j7LgwXJCeM-VvyrQgKa4PGqVu36O44dxSpn3Ca4GCsg,5659
+tools/common/logging.py,sha256=siuAuC2OUKmVa0INWxZZpjTGMHVzfKSZH2lZ54BX-Q4,8364
+tools/common/types.py,sha256=C7SwZWCM115ZxpbuSrrIYQCjWad2_8QZWtUGmzBxtP4,4045
+tools/orchestration/__init__.py,sha256=znI_R1EcCun6_qbkqNaHphEjxUYD7Haayng2uf42aKg,402
+tools/orchestration/cli.py,sha256=a1dIaiHYLTwIT5p7_EUdOoqn4Bj-6BUkb6uoZ0r3wA4,10576
+tools/orchestration/config_loader.py,sha256=rzMZXytxPpiuQhBlz6VBkcX9IyhUIt8nuvWxkp5B0wE,12684
+tools/orchestration/server_orchestrator.py,sha256=ZdqSMkZ8Bx8U6U3wqYWFy7LK30MTNfISSDW693FIpe4,17478
+tools/orchestration/server_registry.py,sha256=piANwfafXDJ-zuOjCNRJACetr6_lZrB_Qc1BXDVaIgo,7119
+tools/orchestration/server_selector.py,sha256=8eHs59e7rhNNWUkgMjZwPxodKnej6EGYE3vJJ99rGcA,9001
+mseep_lightfast_mcp-0.0.1.dist-info/METADATA,sha256=n8uLOk1zJBh1Ye2sB5e06g0VVspfKdVDjv12Q2uwTg0,1294
+mseep_lightfast_mcp-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mseep_lightfast_mcp-0.0.1.dist-info/entry_points.txt,sha256=EF8QP2Lbm_H_MFR0Q3dDHi-alNcPiFfIVJdck225yHg,392
+mseep_lightfast_mcp-0.0.1.dist-info/top_level.txt,sha256=-ZI_xMvvDtxXIaiKOLV8pLB9FMRuWecaUl1eWefmOzg,27
+mseep_lightfast_mcp-0.0.1.dist-info/RECORD,,

mseep_lightfast_mcp-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mseep_lightfast_mcp-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,7 @@
+[console_scripts]
+lightfast-blender = lightfast_mcp.servers.blender.server:main
+lightfast-blender-server = lightfast_mcp.servers.blender_mcp_server:main
+lightfast-conversation-client = tools.ai.conversation_cli:app
+lightfast-mcp-orchestrator = tools.orchestration.cli:main
+lightfast-mock = lightfast_mcp.servers.mock.server:main
+lightfast-mock-server = lightfast_mcp.servers.mock_server:main

mseep_lightfast_mcp-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Lightfast
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mseep_lightfast_mcp-0.0.1.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+common
+lightfast_mcp
+tools

tools/__init__.py

@@ -0,0 +1,46 @@
+"""
+Development tools for lightfast-mcp.
+
+This package contains development and testing tools that are useful for
+multi-server coordination and AI integration, but are not part of the
+core MCP server implementations.
+
+Core MCP servers are in the lightfast_mcp package.
+Development tools are in this tools package.
+
+## Architecture
+- tools.orchestration.ServerOrchestrator: Advanced server management
+- tools.ai.ConversationClient: Modern AI conversation handling
+- tools.common: Shared utilities, types, and error handling
+"""
+
+# Import submodules to make them available for patching in tests
+from . import ai, common, orchestration
+
+# New architecture
+from .ai import ConversationClient, create_conversation_client
+from .orchestration import (
+    ConfigLoader,
+    ServerOrchestrator,
+    ServerRegistry,
+    ServerSelector,
+    get_orchestrator,
+    get_registry,
+)
+
+__all__ = [
+    # Submodules (for test patching)
+    "ai",
+    "common",
+    "orchestration",
+    # Orchestration
+    "ConfigLoader",
+    "ServerOrchestrator",
+    "ServerRegistry",
+    "ServerSelector",
+    "get_orchestrator",
+    "get_registry",
+    # AI
+    "ConversationClient",
+    "create_conversation_client",
+]

tools/ai/__init__.py

@@ -0,0 +1,8 @@
+"""AI integration tools for multi-server coordination."""
+
+from .conversation_client import ConversationClient, create_conversation_client
+
+__all__ = [
+    "ConversationClient",
+    "create_conversation_client",
+]