mcp-nequeo 2.7.26__tar.gz

mcp_nequeo-2.7.26/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) Nequeo 2026 The Python Packaging Authority
+
+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.

mcp_nequeo-2.7.26/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: mcp-nequeo
+Version: 2.7.26
+Summary: Model Context Protocol (MCP) client and server implementation
+Author-email: Drazen Zadravec <noreply@dznequeo.net>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/drazenzadravec/tools/tree/master/ai/mcp
+Project-URL: Issues, https://github.com/drazenzadravec/tools/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Model Context Protocol (MCP) Client and Server
+
+Client supports Stdio and Streamable HTTP. Server supports Stdio and Streamable HTTP.
+
+## Install
+
+pip install mcp-nequeo
+

mcp_nequeo-2.7.26/README.md

@@ -0,0 +1,8 @@
+# Model Context Protocol (MCP) Client and Server
+
+Client supports Stdio and Streamable HTTP. Server supports Stdio and Streamable HTTP.
+
+## Install
+
+pip install mcp-nequeo
+

mcp_nequeo-2.7.26/pyproject.toml

@@ -0,0 +1,19 @@
+[project]
+name = "mcp-nequeo"
+version = "2.7.26"
+authors = [
+  { name="Drazen Zadravec", email="noreply@dznequeo.net" },
+]
+description = "Model Context Protocol (MCP) client and server implementation"
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+[project.urls]
+Homepage = "https://github.com/drazenzadravec/tools/tree/master/ai/mcp"
+Issues = "https://github.com/drazenzadravec/tools/issues"

mcp_nequeo-2.7.26/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mcp_nequeo-2.7.26/src/mcp-nequeo/McpClient.py

@@ -0,0 +1,563 @@
+import httpx
+
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+from mcp.client.streamable_http import streamablehttp_client
+
+from datetime import timedelta
+from pydantic import AnyUrl, TypeAdapter
+from typing import Optional, Any, List, Union, Callable, Dict
+from contextlib import AsyncExitStack, _AsyncGeneratorContextManager
+
+from .McpTypes import McpTool, McpPrompt, McpResource, McpToolParameters
+
+# Model context protocol client.
+class McpClient:
+    """
+    Model context protocol client.
+    """
+    def __init__(self):
+        self.open = False
+        self.timeout: timedelta = timedelta(seconds=60)  # default timeout 60 seconds
+        self.logEvent: Callable[[str, str, str, Any], None] | None = None
+
+        # Initialize session and client objects
+        self.session: Optional[ClientSession] = None
+        self.exit_stack = AsyncExitStack()
+
+        # init
+        self.tools: List[McpTool] = []
+        self.prompts: List[McpPrompt] = []
+        self.resources: List[McpResource] = []
+
+    def onEvent(self, event: Callable[[str, str, str, Any], None]) -> None:
+        """
+        subscribe to the on event.
+        Args:
+            event:   the log event handler.
+        """
+        self.logEvent = event
+
+    def setTimeout(self, timeout: timedelta) -> None:
+        """
+        set the timeout in seconds (default timeout 60 seconds).
+        Args:
+            timeout:    the timeout in seconds.
+        """
+        self.timeout = timeout
+
+    def isConnected(self) -> bool:
+        """
+        is connected to MCP server.
+
+        Return:
+            true if connected to server; else false.
+        """
+        return self.open
+
+    def getTools(self) -> List[McpTool]:
+        """
+        get the list of tools
+
+        Return:
+            the list of tools; else empty.
+        """
+        return self.tools
+
+    def getPrompts(self) -> List[McpPrompt]:
+        """
+        get the list of prompts
+
+        Return:
+            the list of prompts; else empty.
+        """
+        return self.prompts
+
+    def getResources(self) -> List[McpResource]:
+        """
+        get the list of resources
+
+        Return:
+            the list of resources; else empty.
+        """
+        return self.resources
+
+    async def callTool(self, name: str, args: Dict[str, Any] | None = None) -> Any | None:
+        """
+        call the tool.
+
+        Args:
+            name:    the name of the tool
+            args:    the arguments
+
+        Return:
+            the result; else none.
+        """
+        # if open.
+        if self.open:
+            return await self.session.call_tool(name, arguments = args, read_timeout_seconds = self.timeout)
+        else:
+            return None
+
+    async def callPrompt(self, name: str, args: Dict[str, str] | None = None) -> Any | None:
+        """
+        read the resource.
+
+        Args:
+            name:    the name of the prompt
+            args:    the arguments
+
+        Return:
+            the result; else none.
+        """
+        # if open.
+        if self.open:
+            return await self.session.get_prompt(name, arguments = args)
+        else:
+            return None
+
+    async def callResource(self, uri: AnyUrl) -> Any | None:
+        """
+        read the resource.
+
+        Args:
+            uri:    the resource URI
+
+        Return:
+            the result; else none.
+        """
+        # if open.
+        if self.open:
+            return await self.session.read_resource(uri)
+        else:
+            return None
+
+    async def closeConnection(self):
+        """
+        disconnect from the MCP server.
+        """
+        self.session = None
+        self.tools = []
+        self.prompts = []
+        self.resources = []
+
+        try:
+            # close the stack.
+            await self.exit_stack.aclose()
+        except Exception as e:
+            if (self.logEvent):
+                self.logEvent("error", "mcpclient", "client close", e)
+
+        # closed
+        self.logEvent = None
+        self.open = False
+
+    async def openConnectionStdio(self, serverScriptPath: str):
+        """
+        connect to the MCP server.
+        start receiving messages on stdin and sending messages on stdout.
+
+        Args:
+            serverScriptPath: the server script full path
+        """
+
+        # if not open.
+        if not self.open:
+            try:
+
+                # only if JavaScript or Python
+                is_python = serverScriptPath.endswith('.py')
+                is_js = serverScriptPath.endswith('.js')
+
+                # if not JavaScript and not Python
+                if not (is_python or is_js):
+                    raise ValueError("Server script must be a .py or .js file")
+
+                # the command to execute
+                command = "python" if is_python else "node"
+                server_params = StdioServerParameters(
+                    command = command,
+                    args = [serverScriptPath],
+                    env = None
+                )
+
+                # open a connection to the MCP server.
+                stdio_transport = await self.exit_stack.enter_async_context(stdio_client(server_params))
+                self.read, self.write = stdio_transport
+                self.session = await self.exit_stack.enter_async_context(ClientSession(self.read, self.write))
+
+                # start session.
+                await self.session.initialize()
+                
+                # client connected.
+                self.open = True
+
+                # request.
+                await self.requestTools()
+                await self.requestPrompts()
+                await self.requestResources()
+
+            except Exception as e:
+                self.open = False
+                if (self.logEvent):
+                    self.logEvent("error", "open", "open connection stdio", e)
+                raise  # Re-throws the same exception
+
+    async def openConnectionStdioCustom(self, command: str, argsList: List[str] | None = None, envList: Dict[str, str] | None = None):
+        """
+        connect to the MCP server.
+        start receiving messages on stdin and sending messages on stdout.
+
+        Args:
+            command: the executable to run to start the server.
+            argsList: command line arguments to pass to the executable.
+            envList: the environment to use when spawning the process.
+        """
+
+        # if not open.
+        if not self.open:
+            try:
+
+                # the command to execute
+                server_params = StdioServerParameters(
+                    command = command,
+                    args = argsList,
+                    env = envList
+                )
+
+                # open a connection to the MCP server.
+                stdio_transport = await self.exit_stack.enter_async_context(stdio_client(server_params))
+                self.read, self.write = stdio_transport
+                self.session = await self.exit_stack.enter_async_context(ClientSession(self.read, self.write))
+
+                # start session.
+                await self.session.initialize()
+                
+                # client connected.
+                self.open = True
+
+                # request.
+                await self.requestTools()
+                await self.requestPrompts()
+                await self.requestResources()
+
+            except Exception as e:
+                self.open = False
+                if (self.logEvent):
+                    self.logEvent("error", "open", "open connection stdio custom", e)
+                raise  # Re-throws the same exception
+
+    async def openConnectionStdioServerParam(self, server: StdioServerParameters):
+        """
+        connect to the MCP server.
+        start receiving messages on stdin and sending messages on stdout.
+
+        Args:
+            server: stdio server parameters.
+        """
+
+        # if not open.
+        if not self.open:
+            try:
+
+                # open a connection to the MCP server.
+                stdio_transport = await self.exit_stack.enter_async_context(stdio_client(server))
+                self.read, self.write = stdio_transport
+                self.session = await self.exit_stack.enter_async_context(ClientSession(self.read, self.write))
+
+                # start session.
+                await self.session.initialize()
+                
+                # client connected.
+                self.open = True
+
+                # request.
+                await self.requestTools()
+                await self.requestPrompts()
+                await self.requestResources()
+
+            except Exception as e:
+                self.open = False
+                if (self.logEvent):
+                    self.logEvent("error", "open", "open connection stdio server param", e)
+                raise  # Re-throws the same exception
+
+    async def openConnectionHttp(self, serverUrl: str, requestInit: Dict[str, str] | None = None):
+        """
+        connect to the MCP server.
+        start receiving messages on streamable HTTP.
+        For remote servers, set up a Streamable HTTP transport that handles
+        both client requests and server-to-client notifications.
+
+        Args:
+            serverUrl: the server URL path.
+            requestInit:    ustomizes HTTP requests to the server.
+
+        Example:
+            serverUrl:  https://example.com/mcp
+            requestInit: {
+                'Authorization': 'Bearer <secret>'
+            }
+        """
+
+        # if not open.
+        if not self.open:
+            try:
+                http_transport = None
+
+                # open a connection to the MCP server.
+                if(requestInit is None):
+                    http_transport = await self.exit_stack.enter_async_context(
+                        streamablehttp_client(serverUrl, timeout=self.timeout))
+                else:
+                    http_transport = await self.exit_stack.enter_async_context(
+                        streamablehttp_client(url=serverUrl, headers=requestInit, timeout=self.timeout))
+
+                # get streams
+                self.read, self.write, _, = http_transport
+                self.session = await self.exit_stack.enter_async_context(ClientSession(self.read, self.write))
+                
+                # Initialize the connection
+                await self.session.initialize()
+                
+                # client connected.
+                self.open = True
+
+                # request.
+                await self.requestTools()
+                await self.requestPrompts()
+                await self.requestResources()
+                
+            except Exception as e:
+                self.open = False
+                if (self.logEvent):
+                    self.logEvent("error", "open", "open connection http", e)
+                raise  # Re-throws the same exception
+
+    async def openConnectionHttpCustom(self, serverUrl: str, headers: Dict[str, str] | None = None, auth: httpx.Auth | None = None):
+        """
+        connect to the MCP server.
+        start receiving messages on streamable HTTP.
+        For remote servers, set up a Streamable HTTP transport that handles
+        both client requests and server-to-client notifications.
+
+        Args:
+            serverUrl: the server URL path.
+            headers:    ustomizes HTTP requests to the server.
+            auth:    ustomizes HTTP authorization to the server.
+
+        Example:
+            serverUrl:  https://example.com/mcp
+            headers: {
+                'Authorization': 'Bearer <secret>'
+            }
+        """
+
+        # if not open.
+        if not self.open:
+            try:
+                http_transport = None
+
+                # open a connection to the MCP server.
+                http_transport = await self.exit_stack.enter_async_context(
+                    streamablehttp_client(url=serverUrl, headers=headers, timeout=self.timeout, auth=auth))
+                
+                # get streams
+                self.read, self.write, _, = http_transport
+                self.session = await self.exit_stack.enter_async_context(ClientSession(self.read, self.write))
+                
+                # Initialize the connection
+                await self.session.initialize()
+                
+                # client connected.
+                self.open = True
+
+                # request.
+                await self.requestTools()
+                await self.requestPrompts()
+                await self.requestResources()
+                
+            except Exception as e:
+                self.open = False
+                if (self.logEvent):
+                    self.logEvent("error", "open", "open connection http custom", e)
+                raise  # Re-throws the same exception
+
+    async def openConnectionHttpTransport(self, transport: _AsyncGeneratorContextManager):
+        """
+        connect to the MCP server.
+        start receiving messages on streamable HTTP.
+        For remote servers, set up a Streamable HTTP transport that handles
+        both client requests and server-to-client notifications.
+
+        Args:
+            transport: the transport to use to connect to the server. A streamablehttp_client implementation.
+
+        Example:
+            from botocore.credentials import Credentials
+            from mcp_proxy_for_aws.client import aws_iam_streamablehttp_client
+
+            creds = Credentials(access_key="KEY", secret_key="SECRET")
+
+            transport = aws_iam_streamablehttp_client(
+                endpoint="https://example.com/mcp",
+                aws_service="lambda",
+                aws_region="ap-southeast-2",
+                credentials=creds
+            )
+        """
+
+        # if not open.
+        if not self.open:
+            try:
+                http_transport = None
+
+                # open a connection to the MCP server.
+                http_transport = await self.exit_stack.enter_async_context(transport)
+                
+                # get streams
+                self.read, self.write, _, = http_transport
+                self.session = await self.exit_stack.enter_async_context(ClientSession(self.read, self.write))
+                
+                # Initialize the connection
+                await self.session.initialize()
+                
+                # client connected.
+                self.open = True
+
+                # request.
+                await self.requestTools()
+                await self.requestPrompts()
+                await self.requestResources()
+                
+            except Exception as e:
+                self.open = False
+                if (self.logEvent):
+                    self.logEvent("error", "open", "open connection http custom", e)
+                raise  # Re-throws the same exception
+
+    async def requestTools(self) -> bool:
+        """
+        request the tools list.
+
+        Return:
+            true if list call succeeded: else false.
+        """
+        haslist: bool = False
+
+        # if open.
+        if self.open:
+            self.tools = []
+
+            try:
+                # load all tools.
+                toolsResult = await self.session.list_tools()
+                if toolsResult is not None:
+                    if toolsResult.tools is not None:
+                        for tool in toolsResult.tools:
+                            # create the tool model.
+                            self.tools.append(McpTool(
+                                tool.name,
+                                tool.name,
+                                tool.description,
+                                tool.inputSchema,
+                                McpToolParameters(tool.inputSchema)
+                            ))
+
+                haslist = True
+            except Exception as e:
+                if (self.logEvent):
+                    self.logEvent("error", "tools", "request tools", e)
+
+        return haslist
+
+    async def requestPrompts(self) -> bool:
+        """
+        request the prompts list.
+
+        Return:
+            true if list call succeeded: else false.
+        """
+        haslist: bool = False
+
+        # if open.
+        if self.open:
+            self.prompts = []
+
+            try:
+                # load all prompts.
+                promptsResult = await self.session.list_prompts()
+                if promptsResult is not None:
+                    if promptsResult.prompts is not None:
+                        for prompt in promptsResult.prompts:
+                            # create the prompt model.
+                            self.prompts.append(McpPrompt(
+                                prompt.name,
+                                prompt.name,
+                                prompt.description,
+                                prompt.arguments
+                            ))
+
+                haslist = True
+            except Exception as e:
+                if (self.logEvent):
+                    self.logEvent("error", "prompts", "request prompts", e)
+
+        return haslist
+
+    async def requestResources(self) -> bool:
+        """
+        request the resources list.
+
+        Return:
+            true if list call succeeded: else false.
+        """
+        haslist: bool = False
+
+        # if open.
+        if self.open:
+            self.resources = []
+
+            try:
+                # load all resources.
+                resourcesResult = await self.session.list_resources()
+                if resourcesResult is not None:
+                    if resourcesResult.resources is not None:
+                        for resource in resourcesResult.resources:
+                            # create the resource model.
+                            self.resources.append(McpResource(
+                                resource.name,
+                                resource.name,
+                                resource.description,
+                                resource.uri,
+                                resource.mimeType
+                            ))
+
+                haslist = True
+            except Exception as e:
+                haslist = False
+                if (self.logEvent):
+                    self.logEvent("error", "resources", "request resources", e)
+
+            try:
+                # load all resources.
+                resourcesResultTemplates = await self.session.list_resource_templates()
+                if resourcesResultTemplates is not None:
+                    if resourcesResultTemplates.resourceTemplates is not None:
+                        for resource in resourcesResultTemplates.resourceTemplates:
+                            # create the resource model.
+                            self.resources.append(McpResource(
+                                resource.name,
+                                resource.name,
+                                resource.description,
+                                resource.uriTemplate,
+                                resource.mimeType
+                            ))
+
+                haslist = True
+            except Exception as e:
+                haslist = False
+                if (self.logEvent):
+                    self.logEvent("error", "resources_templates", "request resource templates", e)
+        
+        return haslist