Update to use domain_schemas (plural) API from deriva-ml

The DerivaML class changed from domain_schema (singular string) to
domain_schemas (set of strings) and default_schema. This update:

- ConnectionInfo.domain_schema -> domain_schemas (set[str] | None)
- ConnectionManager.connect() parameter updated
- All references to ml.domain_schema updated to use ml.domain_schemas
  or ml.default_schema as appropriate
- Resources now iterate over all domain schemas instead of just one

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: carlkesselman

src/deriva_ml_mcp/connection.py

@@ -50,7 +50,7 @@ class ConnectionInfo:
 
     hostname: str
     catalog_id: str | int
-    domain_schema: str | None
+    domain_schemas: set[str] | None
     ml_instance: DerivaML
     workflow_rid: str | None = None
     execution: Any = None  # Execution object from deriva_ml
@@ -147,15 +147,15 @@ def connect(
         self,
         hostname: str,
         catalog_id: str | int,
-        domain_schema: str | None = None,
+        domain_schemas: set[str] | None = None,
         set_active: bool = True,
     ) -> DerivaML:
         """Connect to a DerivaML catalog.
 
         Args:
             hostname: Hostname of the Deriva server.
             catalog_id: Catalog identifier.
-            domain_schema: Optional domain schema name.
+            domain_schemas: Optional set of domain schema names. Auto-detected if omitted.
             set_active: If True, set this as the active connection.
 
         Returns:
@@ -179,7 +179,7 @@ def connect(
             ml = DerivaML(
                 hostname=hostname,
                 catalog_id=catalog_id,
-                domain_schema=domain_schema,
+                domain_schemas=domain_schemas,
                 check_auth=True,
             )
 
@@ -189,7 +189,7 @@ def connect(
             self._connections[key] = ConnectionInfo(
                 hostname=hostname,
                 catalog_id=catalog_id,
-                domain_schema=domain_schema,
+                domain_schemas=domain_schemas,
                 ml_instance=ml,
                 workflow_rid=workflow_rid,
                 execution=execution,
@@ -339,7 +339,7 @@ def list_connections(self) -> list[dict[str, Any]]:
             {
                 "hostname": info.hostname,
                 "catalog_id": info.catalog_id,
-                "domain_schema": info.domain_schema,
+                "domain_schemas": list(info.domain_schemas) if info.domain_schemas else None,
                 "is_active": key == self._active_connection,
                 "workflow_rid": info.workflow_rid,
                 "execution_rid": info.execution.execution_rid if info.execution else None,

src/deriva_ml_mcp/resources.py

@@ -443,24 +443,27 @@ def get_catalog_schema() -> str:
             schema_info = {
                 "hostname": ml.host_name,
                 "catalog_id": str(ml.catalog_id),
-                "domain_schema": ml.domain_schema,
+                "domain_schemas": list(ml.domain_schemas),
+                "default_schema": ml.default_schema,
                 "ml_schema": ml.ml_schema,
                 "tables": [],
             }
 
-            # Get domain schema tables
-            domain = ml.model.schemas.get(ml.domain_schema)
-            if domain:
-                for table in domain.tables.values():
-                    table_info = {
-                        "name": table.name,
-                        "columns": [
-                            {"name": col.name, "type": str(col.type)}
-                            for col in table.columns
-                        ],
-                        "is_vocabulary": hasattr(table, "is_vocabulary") and table.is_vocabulary,
-                    }
-                    schema_info["tables"].append(table_info)
+            # Get tables from all domain schemas
+            for domain_schema in ml.domain_schemas:
+                domain = ml.model.schemas.get(domain_schema)
+                if domain:
+                    for table in domain.tables.values():
+                        table_info = {
+                            "name": table.name,
+                            "schema": domain_schema,
+                            "columns": [
+                                {"name": col.name, "type": str(col.type)}
+                                for col in table.columns
+                            ],
+                            "is_vocabulary": hasattr(table, "is_vocabulary") and table.is_vocabulary,
+                        }
+                        schema_info["tables"].append(table_info)
 
             return json.dumps(schema_info, indent=2)
         except Exception as e:
@@ -481,7 +484,8 @@ def get_catalog_vocabularies() -> str:
         try:
             vocabularies = {}
             # Iterate through schemas to find vocabulary tables
-            for schema_name in [ml.ml_schema, ml.domain_schema]:
+            schemas_to_check = [ml.ml_schema] + list(ml.domain_schemas)
+            for schema_name in schemas_to_check:
                 schema = ml.model.schemas.get(schema_name)
                 if schema:
                     for table in schema.tables.values():
@@ -617,21 +621,25 @@ def get_catalog_features() -> str:
         mime_type="application/json",
     )
     def get_catalog_tables() -> str:
-        """Return all tables in the domain schema with metadata."""
+        """Return all tables in the domain schemas with metadata."""
         ml = conn_manager.get_active_connection()
         if ml is None:
             return json.dumps({"error": "No active catalog connection"})
 
         try:
             tables = []
-            for table in ml.model.schemas[ml.domain_schema].tables.values():
-                tables.append({
-                    "name": table.name,
-                    "comment": table.comment or "",
-                    "is_vocabulary": ml.model.is_vocabulary(table),
-                    "is_asset": ml.model.is_asset(table),
-                    "column_count": len(list(table.columns)),
-                })
+            for domain_schema in ml.domain_schemas:
+                if domain_schema not in ml.model.schemas:
+                    continue
+                for table in ml.model.schemas[domain_schema].tables.values():
+                    tables.append({
+                        "name": table.name,
+                        "schema": domain_schema,
+                        "comment": table.comment or "",
+                        "is_vocabulary": ml.model.is_vocabulary(table),
+                        "is_asset": ml.model.is_asset(table),
+                        "column_count": len(list(table.columns)),
+                    })
             return json.dumps(tables, indent=2)
         except Exception as e:
             return json.dumps({"error": str(e)})
@@ -1514,7 +1522,8 @@ def get_catalog_info() -> str:
             result = {
                 "hostname": ml.host_name,
                 "catalog_id": str(ml.catalog_id),
-                "domain_schema": ml.domain_schema,
+                "domain_schemas": list(ml.domain_schemas),
+                "default_schema": ml.default_schema,
                 "ml_schema": ml.ml_schema,
                 "project_name": ml.project_name,
             }

src/deriva_ml_mcp/tools/catalog.py

@@ -44,14 +44,17 @@ async def connect_catalog(
             connect_catalog("dev.eye-ai.org", "52") -> connects to eye-ai catalog
         """
         try:
-            ml = conn_manager.connect(hostname, catalog_id, domain_schema)
+            # Convert single domain_schema to set for the new API
+            domain_schemas = {domain_schema} if domain_schema else None
+            ml = conn_manager.connect(hostname, catalog_id, domain_schemas)
             conn_info = conn_manager.get_active_connection_info()
 
             result = {
                 "status": "connected",
                 "hostname": hostname,
                 "catalog_id": catalog_id,
-                "domain_schema": ml.domain_schema,
+                "domain_schemas": list(ml.domain_schemas),
+                "default_schema": ml.default_schema,
                 "project_name": ml.project_name,
             }
 
@@ -133,13 +136,14 @@ async def create_catalog(
             model.create_schema(Schema.define(project_name))
 
             # Connect to the newly created catalog
-            ml = conn_manager.connect(hostname, str(catalog.catalog_id), project_name)
+            ml = conn_manager.connect(hostname, str(catalog.catalog_id), {project_name})
 
             result = {
                 "status": "created",
                 "hostname": hostname,
                 "catalog_id": str(catalog.catalog_id),
-                "domain_schema": ml.domain_schema,
+                "domain_schemas": list(ml.domain_schemas),
+                "default_schema": ml.default_schema,
                 "project_name": project_name,
             }
             if catalog_alias:

src/deriva_ml_mcp/tools/schema.py

@@ -114,7 +114,7 @@ async def create_table(
                 for fk in foreign_keys:
                     fkey_defs.append(ForeignKeyDefinition(
                         colnames=[fk["column"]],
-                        pk_sname=ml.domain_schema,
+                        pk_sname=ml.default_schema,
                         pk_tname=fk["referenced_table"],
                         pk_colnames=[fk.get("referenced_column", "RID")],
                         on_delete=fk.get("on_delete", "NO ACTION"),