`server`¶

Full name: tenets.mcp.server

server¶

Tenets MCP Server implementation.

This module provides the core MCP server that exposes tenets functionality to AI coding assistants via the Model Context Protocol.

The server supports multiple transports: - stdio: Local process communication (default, for IDE integration) - sse: Server-Sent Events (for web-based clients) - http: Streamable HTTP (for remote deployment)

All tools delegate to the existing tenets core library, ensuring consistent behavior between CLI, Python API, and MCP interfaces.

Classes¶

TenetsMCP¶

Python

TenetsMCP(name: str = 'tenets', config: Optional[TenetsConfig] = None, project_path: Optional[Path] = None)

Tenets MCP Server.

Wraps the tenets core library and exposes functionality via MCP protocol. This class manages the FastMCP server instance and handles lifecycle.

ATTRIBUTE	DESCRIPTION
`name`	Server name for MCP identification.
`tenets`	Underlying Tenets instance for actual functionality. TYPE:`Tenets`
`config`	Configuration for the MCP server. TYPE:`Tenets`

Example

from tenets.mcp import TenetsMCP server = TenetsMCP() server.run(transport="stdio")

Initialize the MCP server.

PARAMETER	DESCRIPTION
`name`	Server name shown to MCP clients. TYPE:`str`DEFAULT:`'tenets'`
`config`	Optional TenetsConfig. If not provided, uses defaults. TYPE:`Optional[TenetsConfig]`DEFAULT:`None`
`project_path`	Optional project root path. Defaults to cwd. TYPE:`Optional[Path]`DEFAULT:`None`

Source code in tenets/mcp/server.py

Python

def __init__(
    self,
    name: str = "tenets",
    config: Optional[TenetsConfig] = None,
    project_path: Optional[Path] = None,
):
    """Initialize the MCP server.

    Args:
        name: Server name shown to MCP clients.
        config: Optional TenetsConfig. If not provided, uses defaults.
        project_path: Optional project root path. Defaults to cwd.
    """
    if not _check_mcp_available():
        raise ImportError(
            "MCP dependencies not installed. " "Install with: pip install tenets[mcp]"
        )

    self.name = name
    self._project_path = project_path or Path.cwd()
    self._config = config
    self._tenets: Optional[Tenets] = None
    self._mcp = None
    self._warmed = False
    self._setup_server()

Attributes¶

tenets`property`¶

Python

tenets: Tenets

Lazy-load the Tenets instance.

Functions¶

get_instance`classmethod`¶

Python

get_instance(name: str = 'tenets', config: Optional['TenetsConfig'] = None, project_path: Optional[Path] = None) -> 'TenetsMCP'

Get or create a singleton MCP server instance.

Using a singleton preserves warm state (loaded analyzers, cached results) across multiple tool invocations, significantly improving response times.

PARAMETER	DESCRIPTION
`name`	Server name shown to MCP clients. TYPE:`str`DEFAULT:`'tenets'`
`config`	Optional TenetsConfig. Only used on first creation. TYPE:`Optional['TenetsConfig']`DEFAULT:`None`
`project_path`	Optional project root path. Only used on first creation. TYPE:`Optional[Path]`DEFAULT:`None`

RETURNS	DESCRIPTION
`'TenetsMCP'`	The singleton TenetsMCP instance.

Source code in tenets/mcp/server.py

Python

@classmethod
def get_instance(
    cls,
    name: str = "tenets",
    config: Optional["TenetsConfig"] = None,
    project_path: Optional[Path] = None,
) -> "TenetsMCP":
    """Get or create a singleton MCP server instance.

    Using a singleton preserves warm state (loaded analyzers, cached results)
    across multiple tool invocations, significantly improving response times.

    Args:
        name: Server name shown to MCP clients.
        config: Optional TenetsConfig. Only used on first creation.
        project_path: Optional project root path. Only used on first creation.

    Returns:
        The singleton TenetsMCP instance.
    """
    global _mcp_instance

    with _mcp_instance_lock:
        if _mcp_instance is None:
            _mcp_instance = cls(name=name, config=config, project_path=project_path)
        return _mcp_instance

reset_instance`classmethod`¶

Python

reset_instance() -> None

Reset the singleton instance.

Primarily for testing. Clears the cached instance so the next call to get_instance() creates a fresh server.

Source code in tenets/mcp/server.py

Python

@classmethod
def reset_instance(cls) -> None:
    """Reset the singleton instance.

    Primarily for testing. Clears the cached instance so the next
    call to get_instance() creates a fresh server.
    """
    global _mcp_instance

    with _mcp_instance_lock:
        _mcp_instance = None

warm_components¶

Python

warm_components() -> None

Pre-warm critical components for faster tool responses.

Triggers lazy loading of expensive components (analyzers, rankers) before the first tool invocation, reducing initial response latency.

This is called automatically on server start when using run().

Source code in tenets/mcp/server.py

Python

def warm_components(self) -> None:
    """Pre-warm critical components for faster tool responses.

    Triggers lazy loading of expensive components (analyzers, rankers)
    before the first tool invocation, reducing initial response latency.

    This is called automatically on server start when using run().
    """
    if self._warmed:
        return

    logger = logging.getLogger(__name__)
    logger.debug("Pre-warming MCP server components...")

    try:
        # Trigger lazy loading of the Tenets instance
        tenets = self.tenets

        # Warm the distiller's components
        if hasattr(tenets, "distiller"):
            distiller = tenets.distiller
            # Access analyzer to trigger initialization
            _ = distiller.analyzer
            # Access ranker to trigger initialization
            _ = distiller.ranker
            logger.debug("Distiller components warmed")

        # Pre-warm token encoding cache
        from tenets.utils.tokens import _get_cached_encoding

        _get_cached_encoding(None)  # Default encoding
        _get_cached_encoding("gpt-4o")  # Common model
        logger.debug("Token encoding cache warmed")

        self._warmed = True
        logger.debug("MCP server components pre-warmed successfully")

    except Exception as e:
        logger.warning(f"Failed to pre-warm components: {e}")

run¶

Python

run(transport: Literal['stdio', 'sse', 'http'] = 'stdio', host: str = '127.0.0.1', port: int = 8080, warm: bool = True) -> None

Run the MCP server with the specified transport.

PARAMETER	DESCRIPTION
`transport`	Transport type - stdio (local), sse, or http (remote). TYPE:`Literal['stdio', 'sse', 'http']`DEFAULT:`'stdio'`
`host`	Host for network transports (sse, http). TYPE:`str`DEFAULT:`'127.0.0.1'`
`port`	Port for network transports (sse, http). TYPE:`int`DEFAULT:`8080`
`warm`	Whether to pre-warm components before starting (default True). TYPE:`bool`DEFAULT:`True`

Source code in tenets/mcp/server.py

Python

def run(
    self,
    transport: Literal["stdio", "sse", "http"] = "stdio",
    host: str = "127.0.0.1",
    port: int = 8080,
    warm: bool = True,
) -> None:
    """Run the MCP server with the specified transport.

    Args:
        transport: Transport type - stdio (local), sse, or http (remote).
        host: Host for network transports (sse, http).
        port: Port for network transports (sse, http).
        warm: Whether to pre-warm components before starting (default True).
    """
    # Pre-warm components for faster first response
    if warm:
        self.warm_components()

    if transport == "stdio":
        self._mcp.run(transport="stdio")
    elif transport == "sse":
        self._mcp.run(transport="sse", host=host, port=port)
    elif transport == "http":
        self._mcp.run(transport="streamable-http", host=host, port=port)
    else:
        raise ValueError(f"Unknown transport: {transport}")

Functions¶

create_server¶

Python

create_server(name: str = 'tenets', config: Optional[TenetsConfig] = None, use_singleton: bool = True) -> TenetsMCP

Create or get a Tenets MCP server instance.

Factory function for creating MCP servers. This is the recommended way to instantiate the server for programmatic use.

By default, uses a singleton pattern to preserve warm state across invocations, significantly improving response times for repeated calls.

PARAMETER	DESCRIPTION
`name`	Server name shown to MCP clients. TYPE:`str`DEFAULT:`'tenets'`
`config`	Optional TenetsConfig for customization. TYPE:`Optional[TenetsConfig]`DEFAULT:`None`
`use_singleton`	If True (default), returns a shared singleton instance. Set to False to create a fresh instance each time. TYPE:`bool`DEFAULT:`True`

RETURNS	DESCRIPTION
`TenetsMCP`	Configured TenetsMCP instance ready to run.

Example

from tenets.mcp import create_server server = create_server() server.run(transport="stdio")

Source code in tenets/mcp/server.py

Python

def create_server(
    name: str = "tenets",
    config: Optional[TenetsConfig] = None,
    use_singleton: bool = True,
) -> TenetsMCP:
    """Create or get a Tenets MCP server instance.

    Factory function for creating MCP servers. This is the recommended way
    to instantiate the server for programmatic use.

    By default, uses a singleton pattern to preserve warm state across
    invocations, significantly improving response times for repeated calls.

    Args:
        name: Server name shown to MCP clients.
        config: Optional TenetsConfig for customization.
        use_singleton: If True (default), returns a shared singleton instance.
            Set to False to create a fresh instance each time.

    Returns:
        Configured TenetsMCP instance ready to run.

    Example:
        >>> from tenets.mcp import create_server
        >>> server = create_server()
        >>> server.run(transport="stdio")
    """
    if use_singleton:
        return TenetsMCP.get_instance(name=name, config=config)
    return TenetsMCP(name=name, config=config)

main¶

Python

main() -> None

CLI entry point for tenets-mcp server.

Parses command-line arguments and starts the MCP server with the specified transport configuration.

Source code in tenets/mcp/server.py

Python

def main() -> None:
    """CLI entry point for tenets-mcp server.

    Parses command-line arguments and starts the MCP server with the
    specified transport configuration.
    """
    import argparse

    parser = argparse.ArgumentParser(
        prog="tenets-mcp",
        description="Tenets MCP Server - Intelligent code context for AI assistants",
    )
    parser.add_argument(
        "--transport",
        "-t",
        choices=["stdio", "sse", "http"],
        default="stdio",
        help="Transport type (default: stdio)",
    )
    parser.add_argument(
        "--host",
        default="127.0.0.1",
        help="Host for network transports (default: 127.0.0.1)",
    )
    parser.add_argument(
        "--port",
        "-p",
        type=int,
        default=8080,
        help="Port for network transports (default: 8080)",
    )
    parser.add_argument(
        "--version",
        "-v",
        action="store_true",
        help="Show version and exit",
    )

    args = parser.parse_args()

    if args.version:
        from tenets import __version__

        print(f"tenets-mcp v{__version__}", file=sys.stderr)
        sys.exit(0)

    # Configure logging BEFORE importing anything else
    _configure_mcp_logging(args.transport)

    try:
        server = create_server()
        server.run(
            transport=args.transport,
            host=args.host,
            port=args.port,
        )
    except ImportError as e:
        print(f"Error: {e}", file=sys.stderr)
        print("Install MCP dependencies with: pip install tenets[mcp]", file=sys.stderr)
        sys.exit(1)
    except KeyboardInterrupt:
        print("\nServer stopped.", file=sys.stderr)
        sys.exit(0)

server¶

server¶

Classes¶

TenetsMCP¶

Attributes¶

tenetsproperty¶

Functions¶

get_instanceclassmethod¶

reset_instanceclassmethod¶

warm_components¶

run¶

Functions¶

create_server¶

main¶

`server`¶

tenets`property`¶

get_instance`classmethod`¶

reset_instance`classmethod`¶