Merge branch 'master' into add-mseep-badge-911b94f0

Author: daimor

README.md

@@ -6,6 +6,10 @@
   <img width="380" height="200" src="https://glama.ai/mcp/servers/@caretdev/mcp-server-iris/badge" />
 </a>
 
+[![MseeP.ai Security Assessment Badge](https://mseep.net/pr/caretdev-mcp-server-iris-badge.png)](https://mseep.ai/app/caretdev-mcp-server-iris)
+
+# mcp-server-iris: An InterSystems IRIS MCP server
+
 ## Overview
 
 A [Model Context Protocol](https://modelcontextprotocol.io/introduction) server for InterSystems IRIS database interaction and automation.

docker-compose.yml

@@ -0,0 +1,10 @@
+services:
+  database:
+    image: containers.intersystems.com/intersystems/iris-community:2025.1
+    restart: always
+    ports:
+      - "1972:1972"
+      - "52773:52773"
+    command:
+      - -a
+      - iris session iris -U%SYS '##class(Security.Users).UnExpireUserPasswords("*")'

example.py

@@ -0,0 +1,80 @@
+import sys
+import asyncio
+from typing import Optional
+from contextlib import AsyncExitStack
+
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+
+from dotenv import load_dotenv
+
+load_dotenv()  # load environment variables from .env
+
+
+class MCPClient:
+    def __init__(self):
+        # Initialize session and client objects
+        self.session: Optional[ClientSession] = None
+        self.exit_stack = AsyncExitStack()
+
+    async def connect_to_server(self):
+        """Connect to an MCP server"""
+        server_params = StdioServerParameters(
+            command=sys.executable, args=["-m", "mcp_server_iris"], env={
+                "IRIS_HOSTNAME": "localhost",
+                "IRIS_PORT": "1972",
+                "IRIS_NAMESPACE": "USER",
+                "IRIS_USERNAME": "_SYSTEM",
+                "IRIS_PASSWORD": "SYS",
+            }
+        )
+        # server_params = StdioServerParameters(
+        #     command="uvx", args=["."],
+        # )
+
+        stdio_transport = await self.exit_stack.enter_async_context(
+            stdio_client(server_params)
+        )
+        self.stdio, self.write = stdio_transport
+        self.session = await self.exit_stack.enter_async_context(
+            ClientSession(self.stdio, self.write)
+        )
+
+        await self.session.initialize()
+
+        # List available tools
+        response = await self.session.list_tools()
+        tools = response.tools
+        print(
+            "\nConnected to server with tools:",
+            "\n\t".join([""] + [tool.name for tool in tools]),
+        )
+
+    async def process_query(self, query: str) -> str:
+        response = await self.session.call_tool(
+            "execute_sql",
+            {
+                "query": query,
+                "params": [],
+            },
+        )
+        print("Response from execute_sql:", response.content)
+        return
+
+    async def cleanup(self):
+        """Clean up resources"""
+        await self.exit_stack.aclose()
+
+
+async def main():
+    client = MCPClient()
+    try:
+        await client.connect_to_server()
+        await client.session.set_logging_level("debug")
+        await client.process_query("select $namespace, $zversion")
+    finally:
+        await client.cleanup()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mcp-server-iris"
-version = "0.2.1"
+version = "0.3.1"
 description = "A Model Context Protocol server for InterSystems IRIS."
 readme = "README.md"
 requires-python = ">=3.10"

pytest.ini

@@ -0,0 +1,5 @@
+[pytest]
+asyncio_mode = auto
+asyncio_default_fixture_loop_scope = function
+testpaths = tests
+python_files = test_*.py

src/mcp_server_iris/mcpserver.py

@@ -12,15 +12,15 @@
 from mcp.server.fastmcp.resources import ResourceManager
 from mcp.server.fastmcp import FastMCP
 from mcp.server.fastmcp import Context as FastMCPContext
-from mcp.shared.context import LifespanContextT
+from mcp.shared.context import LifespanContextT, RequestT
 from mcp.server.fastmcp.utilities.logging import configure_logging, get_logger
 
 logger = get_logger(__name__)
 
 Context = FastMCPContext
 
 
-class MCPServerContext(Context, Generic[ServerSessionT, LifespanContextT]):
+class MCPServerContext(Context, Generic[ServerSessionT, LifespanContextT, RequestT]):
     def __init__(
         self,
         *,
@@ -98,6 +98,8 @@ def __init__(
         )
 
         self.settings = Settings(**settings)
+        configure_logging(self.settings.log_level)
+        logger.setLevel(self.settings.log_level.upper())
 
         self._tool_manager = ToolManager(
             warn_on_duplicate_tools=self.settings.warn_on_duplicate_tools
@@ -110,8 +112,13 @@ def __init__(
         )
 
         self._setup_handlers()
+        self._mcp_server.set_logging_level()(self.set_logging_level)
 
-        configure_logging(self.settings.log_level)
+    async def set_logging_level(self, level) -> None:
+        """Set the logging level for the server."""
+        logger.info(f"Logging level set to {level}")
+        logger.setLevel(level.upper())
+        configure_logging(level=level)
 
     @property
     def name(self) -> str:
@@ -138,7 +145,7 @@ def run(self, transport: Literal["stdio", "sse"] = "stdio") -> None:
         Args:
             transport: Transport protocol to use ("stdio" or "sse")
         """
-
+        logger.info(f"Running server with transport: {transport}")
         TRANSPORTS = Literal["stdio", "sse"]
         if transport not in TRANSPORTS.__args__:  # type: ignore
             raise ValueError(f"Unknown transport: {transport}")

src/mcp_server_iris/server.py

@@ -1,42 +1,47 @@
 import os
-import logging
 from importlib.metadata import version
 from contextlib import asynccontextmanager
 from collections.abc import AsyncIterator
 import mcp.types as types
 import iris as irisnative
-from mcp_server_iris.mcpserver import MCPServer, Context
+from mcp_server_iris.mcpserver import MCPServer, Context, logger
 from mcp_server_iris.interoperability import init as interoperability
 
-logger = logging.getLogger("mcp_server_iris")
 logger.info("Starting InterSystems IRIS MCP Server")
 
 
 def get_db_config():
     """Get database configuration from environment variables."""
     config = {
-        "hostname": os.getenv("IRIS_HOSTNAME", "localhost"),
+        "hostname": os.getenv("IRIS_HOSTNAME"),
         "port": int(os.getenv("IRIS_PORT", 1972)),
-        "namespace": os.getenv("IRIS_NAMESPACE", "USER"),
-        "username": os.getenv("IRIS_USERNAME", "_SYSTEM"),
-        "password": os.getenv("IRIS_PASSWORD", "SYS"),
+        "namespace": os.getenv("IRIS_NAMESPACE"),
+        "username": os.getenv("IRIS_USERNAME"),
+        "password": os.getenv("IRIS_PASSWORD"),
     }
 
-    if not all([config["username"], config["password"], config["namespace"]]):
+    if not all([config["hostname"], config["username"], config["password"], config["namespace"]]):
         raise ValueError("Missing required database configuration")
+    logger.info(f"Server configuration: iris://{config["username"]}:{"x"*8}@{config["hostname"]}:{config["port"]}/{config["namespace"]}")
 
     return config
 
 
 @asynccontextmanager
 async def server_lifespan(server: MCPServer) -> AsyncIterator[dict]:
     """Manage server startup and shutdown lifecycle."""
-    config = get_db_config()
     try:
-        db = irisnative.connect(**config)
+        config = get_db_config()
+    except ValueError:
+        yield {"db": None, "iris": None}
+        return
+    try:
+
+        db = irisnative.connect(sharedmemory=False, **config)
         iris = irisnative.createIRIS(db)
         yield {"db": db, "iris": iris}
-    except Exception:
+    except Exception as ex:
+        logger.error(f"Error connecting to IRIS: {ex}")
         db = None
         iris = None
         yield {"db": db, "iris": iris}
@@ -189,7 +194,10 @@ def main():
     args = parser.parse_args()
     server.settings.port = args.port
     server.settings.debug = args.debug
-    server.run(transport=args.transport)
+    try:
+        server.run(transport=args.transport)
+    except KeyboardInterrupt:
+        logger.info("Server stopped by user")
 
 
 if __name__ == "__main__":

tests/test_server.py

@@ -1,5 +1,6 @@
 import sys
 import pytest
+import json
 from mcp.client.session import ClientSession
 from mcp.client.stdio import StdioServerParameters, stdio_client
 from mcp_server_iris.server import server
@@ -41,13 +42,23 @@ async def test_params_in_tool():
 @pytest.mark.asyncio
 async def test_call_tool_execute_sql(iris_config):
     """Test calling execute_sql with a query."""
-    async with stdio_client(StdioServerParameters(command=sys.executable, args=["-m", "mcp_server_iris"], env=iris_config)) as (read, write):
+    async with stdio_client(
+        StdioServerParameters(
+            command=sys.executable, args=["-m", "mcp_server_iris"], env=iris_config
+        )
+    ) as (read, write):
         async with ClientSession(read, write) as session:
             await session.initialize()
-            _ = await session.call_tool(
+            res = await session.call_tool(
                 "execute_sql",
                 {
                     "query": "select $namespace, $zversion",
                     "params": [],
                 },
             )
+            assert res is not None
+            assert not res.isError
+            assert res.content[0].type == "text"
+            text = res.content[0].text
+            assert len(text)
+            print(f"Result: {text}")