friday-framework-mcp 0.1.0a0__tar.gz

friday_framework_mcp-0.1.0a0/.gitignore

@@ -0,0 +1,24 @@
+__pycache__/
+*.pyc
+.env
+.venv/
+.idea/
+.vscode/
+dist/
+build/
+*.egg-info/
+chroma_db/
+.friday/
+/vector/
+/exports/
+tests/integration/memory/vector/*/
+tests/integration/memory/vector/backups/*/
+tests/integration/memory/vector/reorganization_logs/*
+*.gpickle
+keys.txt
+experiments/*/config/runtime.local.yaml
+experiments/*/artifacts/*
+!experiments/*/artifacts/.gitkeep
+scripts/source-friday-chat-example-env.sh
+scripts/pypi.sh
+/docs/reference/PyPI-Recovery-Codes-cichuck-2026-07-20T15_36_49.709334.txt

friday_framework_mcp-0.1.0a0/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: friday-framework-mcp
+Version: 0.1.0a0
+Summary: MCP (Model Context Protocol) integration for Friday Framework
+Project-URL: Homepage, https://github.com/CIChuck/agent-framework
+Project-URL: Repository, https://github.com/CIChuck/agent-framework
+Project-URL: Issues, https://github.com/CIChuck/agent-framework/issues
+Project-URL: Documentation, https://github.com/CIChuck/agent-framework/tree/main/docs
+Project-URL: Source, https://github.com/CIChuck/agent-framework/tree/main/packages/friday-mcp
+Author: Friday Team
+License-Expression: MIT
+Keywords: agents,ai,llm,mcp,model-context-protocol
+Requires-Python: >=3.10
+Requires-Dist: friday-framework-core==0.1.0a0
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest-mock>=3.10.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Provides-Extra: full
+Requires-Dist: fastapi>=0.100.0; extra == 'full'
+Requires-Dist: friday-framework-agent==0.1.0a0; extra == 'full'
+Requires-Dist: friday-framework-tools==0.1.0a0; extra == 'full'
+Requires-Dist: uvicorn>=0.23.0; extra == 'full'
+Provides-Extra: server
+Requires-Dist: fastapi>=0.100.0; extra == 'server'
+Requires-Dist: uvicorn>=0.23.0; extra == 'server'
+Description-Content-Type: text/markdown
+
+# Friday Framework MCP
+
+MCP (Model Context Protocol) integration for the Friday Framework.
+
+## Features
+
+- **MCP Client**: Connect to external MCP servers and consume their tools
+- **MCP Server**: Expose Friday capabilities (agent or tools) via MCP
+- **Transport Support**: Both stdio (subprocess) and SSE (HTTP streaming)
+- **Tool Adaptation**: Seamlessly adapt MCP tools to Friday's ToolDefinition protocol
+
+## Installation
+
+```bash
+# Core package
+pip install friday-framework-mcp
+
+# With SSE server support
+pip install friday-framework-mcp[server]
+
+# Full integration with Friday
+pip install friday-framework-mcp[full]
+```
+
+## Quick Start
+
+### Connecting to MCP Servers (Client)
+
+```python
+from friday_mcp import MCPClientManager, MCPConfig, MCPServerConfig
+
+config = MCPConfig(
+    servers=[
+        MCPServerConfig(
+            name="filesystem",
+            command="npx",
+            args=["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
+        )
+    ]
+)
+
+async with MCPClientManager(config) as manager:
+    tools = await manager.get_all_tools()
+    # Use tools with Friday's agent
+```
+
+### Exposing Friday as MCP Server
+
+```python
+from friday_mcp import StdioMCPServer, MCPServerSettings
+from friday_mcp.server.agent_mode import configure_agent_mode
+
+server = StdioMCPServer()
+configure_agent_mode(server, agent, profile, MCPServerSettings())
+await server.start()
+```
+
+## License
+
+MIT

friday_framework_mcp-0.1.0a0/README.md

@@ -0,0 +1,60 @@
+# Friday Framework MCP
+
+MCP (Model Context Protocol) integration for the Friday Framework.
+
+## Features
+
+- **MCP Client**: Connect to external MCP servers and consume their tools
+- **MCP Server**: Expose Friday capabilities (agent or tools) via MCP
+- **Transport Support**: Both stdio (subprocess) and SSE (HTTP streaming)
+- **Tool Adaptation**: Seamlessly adapt MCP tools to Friday's ToolDefinition protocol
+
+## Installation
+
+```bash
+# Core package
+pip install friday-framework-mcp
+
+# With SSE server support
+pip install friday-framework-mcp[server]
+
+# Full integration with Friday
+pip install friday-framework-mcp[full]
+```
+
+## Quick Start
+
+### Connecting to MCP Servers (Client)
+
+```python
+from friday_mcp import MCPClientManager, MCPConfig, MCPServerConfig
+
+config = MCPConfig(
+    servers=[
+        MCPServerConfig(
+            name="filesystem",
+            command="npx",
+            args=["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
+        )
+    ]
+)
+
+async with MCPClientManager(config) as manager:
+    tools = await manager.get_all_tools()
+    # Use tools with Friday's agent
+```
+
+### Exposing Friday as MCP Server
+
+```python
+from friday_mcp import StdioMCPServer, MCPServerSettings
+from friday_mcp.server.agent_mode import configure_agent_mode
+
+server = StdioMCPServer()
+configure_agent_mode(server, agent, profile, MCPServerSettings())
+await server.start()
+```
+
+## License
+
+MIT

friday_framework_mcp-0.1.0a0/pyproject.toml

@@ -0,0 +1,71 @@
+[project]
+name = "friday-framework-mcp"
+version = "0.1.0a0"
+description = "MCP (Model Context Protocol) integration for Friday Framework"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [{ name = "Friday Team" }]
+keywords = ["ai", "agents", "mcp", "model-context-protocol", "llm"]
+
+dependencies = [
+    # Core protocols
+    "friday-framework-core==0.1.0a0",
+
+    # HTTP client for SSE transport
+    "httpx>=0.25.0",
+
+    # Configuration models
+    "pydantic>=2.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/CIChuck/agent-framework"
+Repository = "https://github.com/CIChuck/agent-framework"
+Issues = "https://github.com/CIChuck/agent-framework/issues"
+Documentation = "https://github.com/CIChuck/agent-framework/tree/main/docs"
+Source = "https://github.com/CIChuck/agent-framework/tree/main/packages/friday-mcp"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.23.0",
+    "pytest-mock>=3.10.0",
+]
+
+# SSE server support (FastAPI-based)
+server = [
+    "fastapi>=0.100.0",
+    "uvicorn>=0.23.0",
+]
+
+# Full integration with Friday packages
+full = [
+    "friday-framework-mcp[server]==0.1.0a0",
+    "friday-framework-tools==0.1.0a0",
+    "friday-framework-agent==0.1.0a0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/friday_mcp"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests_mcp"]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+
+[tool.uv.sources]
+friday-framework-core = { workspace = true }
+friday-framework-tools = { workspace = true }
+friday-framework-agent = { workspace = true }
+
+[tool.ruff]
+line-length = 88
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM"]

friday_framework_mcp-0.1.0a0/src/friday_mcp/__init__.py

@@ -0,0 +1,95 @@
+# mypy: ignore-errors
+"""
+Friday MCP Integration Package.
+
+Provides bidirectional Model Context Protocol (MCP) integration:
+- MCP Client: Connect to external MCP servers and consume their tools
+- MCP Server: Expose Friday capabilities (agent or tools) via MCP
+
+Example (Client - connecting to MCP servers):
+    from friday_mcp import MCPClientManager, MCPConfig, MCPServerConfig
+
+    config = MCPConfig(
+        servers=[
+            MCPServerConfig(
+                name="filesystem",
+                command="npx",
+                args=["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
+            )
+        ]
+    )
+
+    async with MCPClientManager(config) as manager:
+        tools = await manager.get_all_tools()
+        # Register tools with Friday's registry
+
+Example (Server - exposing Friday via MCP):
+    from friday_mcp import StdioMCPServer, MCPServerSettings
+    from friday_mcp.server.agent_mode import configure_agent_mode
+
+    server = StdioMCPServer()
+    configure_agent_mode(server, agent, profile, settings)
+    await server.start()
+"""
+
+from friday_mcp.config import (
+    MCPConfig,
+    MCPServerConfig,
+    MCPServerSettings,
+    ServerMode,
+    TransportType,
+)
+from friday_mcp.protocols import (
+    MCPClient,
+    MCPServer,
+    MCPTransport,
+    ToolAdapter,
+    ToolDefinition,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    # Protocols
+    "MCPClient",
+    "MCPServer",
+    "MCPTransport",
+    "ToolDefinition",
+    "ToolAdapter",
+    # Configuration
+    "MCPConfig",
+    "MCPServerConfig",
+    "MCPServerSettings",
+    "TransportType",
+    "ServerMode",
+]
+
+
+# Lazy imports for client/server implementations
+def __getattr__(name: str):
+    """Lazy import client and server implementations."""
+    if name == "MCPClientManager":
+        from friday_mcp.client.manager import MCPClientManager
+
+        return MCPClientManager
+    if name == "StdioMCPClient":
+        from friday_mcp.client.stdio import StdioMCPClient
+
+        return StdioMCPClient
+    if name == "SSEMCPClient":
+        from friday_mcp.client.sse import SSEMCPClient
+
+        return SSEMCPClient
+    if name == "MCPToolAdapter":
+        from friday_mcp.client.adapter import MCPToolAdapter
+
+        return MCPToolAdapter
+    if name == "StdioMCPServer":
+        from friday_mcp.server.stdio import StdioMCPServer
+
+        return StdioMCPServer
+    if name == "SSEMCPServer":
+        from friday_mcp.server.sse import SSEMCPServer
+
+        return SSEMCPServer
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

friday_framework_mcp-0.1.0a0/src/friday_mcp/client/__init__.py

@@ -0,0 +1,26 @@
+# mypy: ignore-errors
+"""
+MCP Client implementations.
+
+Provides clients for connecting to external MCP servers:
+- StdioMCPClient: Connect via subprocess stdio
+- SSEMCPClient: Connect via HTTP Server-Sent Events
+- MCPClientManager: Manage multiple server connections
+- MCPToolAdapter: Adapt MCP tools to Friday's ToolDefinition
+"""
+
+from friday_mcp.client.adapter import MCPToolAdapter, MCPToolWrapper
+from friday_mcp.client.base import MCPClientBase, MCPError
+from friday_mcp.client.manager import MCPClientManager
+from friday_mcp.client.sse import SSEMCPClient
+from friday_mcp.client.stdio import StdioMCPClient
+
+__all__ = [
+    "MCPClientBase",
+    "MCPError",
+    "StdioMCPClient",
+    "SSEMCPClient",
+    "MCPClientManager",
+    "MCPToolAdapter",
+    "MCPToolWrapper",
+]

friday_framework_mcp-0.1.0a0/src/friday_mcp/client/adapter.py

@@ -0,0 +1,212 @@
+# mypy: ignore-errors
+"""
+MCP Tool Adapter.
+
+Adapts MCP tools to Friday's ToolDefinition protocol.
+Follows the pattern from friday-tools/adapters/.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+from friday_core.interfaces.tools import SchemaFormat
+
+from friday_mcp.protocols import MCPClient, ToolDefinition
+from friday_mcp.utils.schema import mcp_to_friday_schema
+
+if TYPE_CHECKING:
+    from friday_mcp.client.base import MCPClientBase
+
+logger = logging.getLogger(__name__)
+
+
+class MCPToolWrapper:
+    """
+    Wraps an MCP tool as a Friday ToolDefinition.
+
+    Similar to LangChainToolWrapper and AnthropicToolWrapper
+    in friday-tools/adapters/.
+    """
+
+    def __init__(
+        self,
+        client: MCPClient,
+        tool_def: dict[str, Any],
+        name_prefix: str = "",
+    ):
+        """
+        Initialize MCP tool wrapper.
+
+        Args:
+            client: Connected MCP client for executing the tool
+            tool_def: MCP tool definition from tools/list
+            name_prefix: Optional prefix for tool name
+        """
+        self._client = client
+        self._tool_def = tool_def
+        self._name_prefix = name_prefix
+        self._original_name = tool_def.get("name", "unknown")
+
+    @property
+    def name(self) -> str:
+        """Tool name with optional prefix."""
+        if self._name_prefix:
+            return f"{self._name_prefix}{self._original_name}"
+        return self._original_name
+
+    @property
+    def description(self) -> str:
+        """Tool description."""
+        return self._tool_def.get("description", f"MCP tool: {self._original_name}")
+
+    @property
+    def parameters_schema(self) -> dict[str, Any]:
+        """Convert MCP inputSchema to Friday parameters_schema."""
+        input_schema = self._tool_def.get("inputSchema", {})
+        return mcp_to_friday_schema(input_schema)
+
+    async def execute(self, **kwargs: Any) -> str:
+        """Execute the tool via MCP client."""
+        return await self._client.call_tool(self._original_name, kwargs)
+
+    def to_schema(self, format: str = "plain") -> dict[str, Any]:
+        """
+        Convert to JSON schema format for LLM function calling.
+
+        Args:
+            format: Output format - "plain" or "openai".
+
+        Returns:
+            Dictionary suitable for LLM function calling.
+        """
+        plain_schema = {
+            "name": self.name,
+            "description": self.description,
+            "parameters": self.parameters_schema,
+        }
+
+        if format == SchemaFormat.OPENAI or format == "openai":
+            return {
+                "type": "function",
+                "function": plain_schema,
+            }
+
+        return plain_schema
+
+    def __repr__(self) -> str:
+        return f"MCPToolWrapper(name={self.name!r})"
+
+
+class MCPToolAdapter:
+    """
+    Adapts MCP tools to Friday's ToolDefinition protocol.
+
+    Example:
+        client = StdioMCPClient(...)
+        await client.connect()
+
+        adapter = MCPToolAdapter(client, prefix="mcp_filesystem_")
+        tools = await adapter.get_tools()
+
+        # Register with Friday's registry
+        for tool in tools:
+            registry.register(tool)
+    """
+
+    def __init__(
+        self,
+        client: MCPClientBase,
+        prefix: str = "",
+    ):
+        """
+        Initialize adapter.
+
+        Args:
+            client: Connected MCP client
+            prefix: Prefix to add to tool names (e.g., "mcp_filesystem_")
+        """
+        self._client = client
+        self._prefix = prefix
+        self._tools_cache: list[MCPToolWrapper] | None = None
+
+    async def get_tools(self, refresh: bool = False) -> list[ToolDefinition]:
+        """
+        Get all tools from the MCP server as Friday ToolDefinitions.
+
+        Args:
+            refresh: Force refresh of cached tools
+
+        Returns:
+            List of wrapped tools implementing ToolDefinition protocol.
+        """
+        if self._tools_cache is not None and not refresh:
+            return list(self._tools_cache)
+
+        mcp_tools = await self._client.list_tools()
+        self._tools_cache = [
+            MCPToolWrapper(self._client, tool_def, self._prefix)
+            for tool_def in mcp_tools
+        ]
+
+        logger.debug(f"Adapted {len(self._tools_cache)} tools from {self._client.name}")
+
+        return list(self._tools_cache)
+
+    async def get_tool(self, name: str) -> ToolDefinition | None:
+        """
+        Get a specific tool by name.
+
+        Args:
+            name: Tool name (with or without prefix)
+
+        Returns:
+            Wrapped tool or None if not found
+        """
+        tools = await self.get_tools()
+
+        # Try exact match first
+        for tool in tools:
+            if tool.name == name:
+                return tool
+
+        # Try matching original name (without prefix)
+        for tool in tools:
+            if isinstance(tool, MCPToolWrapper) and tool._original_name == name:
+                return tool
+
+        return None
+
+    def adapt(self, tool_def: dict[str, Any]) -> ToolDefinition:
+        """
+        Adapt a single tool definition.
+
+        Args:
+            tool_def: MCP tool definition
+
+        Returns:
+            Wrapped tool
+        """
+        return MCPToolWrapper(self._client, tool_def, self._prefix)
+
+    def adapt_many(self, tool_defs: list[dict[str, Any]]) -> list[ToolDefinition]:
+        """
+        Adapt multiple tool definitions.
+
+        Args:
+            tool_defs: List of MCP tool definitions
+
+        Returns:
+            List of wrapped tools
+        """
+        return [self.adapt(tool_def) for tool_def in tool_defs]
+
+    @property
+    def client_name(self) -> str:
+        """Get the name of the underlying client."""
+        return self._client.name
+
+    def clear_cache(self) -> None:
+        """Clear the tools cache."""
+        self._tools_cache = None