feat: init resources

src/mcp_cordra/server.py

@@ -5,6 +5,7 @@ import json
 import logging
 
 from mcp.server.fastmcp import FastMCP
+from mcp.server.fastmcp.resources import FunctionResource
 
 from .client import (
     CordraClient,
@@ -24,7 +25,11 @@ cordra_client = CordraClient(config)
 logger = logging.getLogger(__name__)
 
 
-@mcp.resource("cordra://objects/{prefix}/{suffix}", name="cordra-object", description="Retrieve a Cordra digital object by ID")
+@mcp.resource(
+    "cordra://objects/{prefix}/{suffix}",
+    name="cordra-object",
+    description="Retrieve a Cordra digital object by ID",
+)
 async def get_cordra_object(prefix: str, suffix: str) -> str:
     """Retrieve a Cordra digital object by its ID.
 
@@ -69,30 +74,29 @@ async def create_schema_resource(schema_name: str) -> str:
         raise RuntimeError(f"Failed to retrieve schema {schema_name}: {e}") from e
 
 
-async def register_schema_resources():
+async def register_schema_resources() -> None:
     """Register individual schema resources dynamically."""
     try:
         # Get all available schemas
         schemas = await cordra_client.find("type:Schema")
 
-        # Add individual schema resources
         for schema in schemas:
-            if isinstance(schema, dict) and 'content' in schema and 'name' in schema['content']:
+            schema_name = schema.get("content", {}).get("name")
-                schema_name = schema['content']['name']
+            if not schema_name:
+                logger.warning("Schema without a name found, skipping.")
+                continue
 
-                # Create an async resource handler for this specific schema
+            logger.info(f"Registering schema resource for cordra type {schema_name}")
-                # Use a closure to capture the schema_name properly
+            async def schema_fn(name: str = schema_name) -> str:
-                def make_schema_handler(captured_name):
+                return await create_schema_resource(name)
-                    async def schema_handler():
+            mcp.add_resource(
-                        return await create_schema_resource(captured_name)
+                FunctionResource.from_function(
-                    return schema_handler
+                    uri=f"cordra://schemas/{schema_name}",
-                
+                    fn=schema_fn,
-                # Register using the decorator approach
+                    name=f"cordra-type-schema-{schema_name}",
-                mcp.resource(
+                    description=f"JSON schema for Cordra type {schema_name}",
-                    f"cordra://schemas/{schema_name}",
+                )
-                    name=f"cordra-schema-{schema_name}",
+            )
-                    description=f"Cordra schema definition for {schema_name}"
-                )(make_schema_handler(schema_name))
 
         logger.info(f"Registered {len(schemas)} schema resources")
 
@@ -106,13 +110,16 @@ async def ping() -> str:
     return "pong"
 
 
+async def initialize_server() -> None:
+    """Initialize server resources before starting."""
+    logger.info("Initializing Cordra MCP server...")
+    await register_schema_resources()
+    logger.info("Server initialization complete")
+
+
 def main() -> None:
     """Main entry point for the MCP server."""
-    async def startup():
+    asyncio.run(initialize_server())
-        await register_schema_resources()
-    
-    # Run startup tasks, then start the server
-    asyncio.run(startup())
     mcp.run()