Skip to content

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.

ATTRIBUTEDESCRIPTION
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.

PARAMETERDESCRIPTION
name

Server name shown to MCP clients.

TYPE:strDEFAULT:'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._setup_server()
Attributes
tenetsproperty
Python
tenets: Tenets

Lazy-load the Tenets instance.

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

Run the MCP server with the specified transport.

PARAMETERDESCRIPTION
transport

Transport type - stdio (local), sse, or http (remote).

TYPE:Literal['stdio', 'sse', 'http']DEFAULT:'stdio'

host

Host for network transports (sse, http).

TYPE:strDEFAULT:'127.0.0.1'

port

Port for network transports (sse, http).

TYPE:intDEFAULT:8080

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,
) -> 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).
    """
    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) -> TenetsMCP

Create a new Tenets MCP server instance.

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

PARAMETERDESCRIPTION
name

Server name shown to MCP clients.

TYPE:strDEFAULT:'tenets'

config

Optional TenetsConfig for customization.

TYPE:Optional[TenetsConfig]DEFAULT:None

RETURNSDESCRIPTION
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,
) -> TenetsMCP:
    """Create a new Tenets MCP server instance.

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

    Args:
        name: Server name shown to MCP clients.
        config: Optional TenetsConfig for customization.

    Returns:
        Configured TenetsMCP instance ready to run.

    Example:
        >>> from tenets.mcp import create_server
        >>> server = create_server()
        >>> server.run(transport="stdio")
    """
    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__}")
        sys.exit(0)

    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.")
        sys.exit(0)