remdb 0.3.172__py3-none-any.whl → 0.3.223__py3-none-any.whl

rem/agentic/providers/pydantic_ai.py

@@ -579,60 +579,62 @@ async def create_agent(
     # Extract schema fields using typed helpers
     from ..schema import get_system_prompt, get_metadata
 
-    # Track whether mcp_servers was explicitly configured (even if empty)
-    mcp_servers_explicitly_set = False
-
     if agent_schema:
         system_prompt = get_system_prompt(agent_schema)
         metadata = get_metadata(agent_schema)
-        # Check if mcp_servers was explicitly set (could be empty list to disable)
-        if hasattr(metadata, 'mcp_servers') and metadata.mcp_servers is not None:
-            mcp_server_configs = [s.model_dump() for s in metadata.mcp_servers]
-            mcp_servers_explicitly_set = True
-        else:
-            mcp_server_configs = []
         resource_configs = metadata.resources if hasattr(metadata, 'resources') else []
 
+        # DEPRECATED: mcp_servers in agent schemas is ignored
+        # MCP servers are now always auto-detected at the application level
+        if hasattr(metadata, 'mcp_servers') and metadata.mcp_servers:
+            logger.warning(
+                "DEPRECATED: mcp_servers in agent schema is ignored. "
+                "MCP servers are auto-detected from tools.mcp_server module. "
+                "Remove mcp_servers from your agent schema."
+            )
+
         if metadata.system_prompt:
             logger.debug("Using custom system_prompt from json_schema_extra")
     else:
         system_prompt = ""
         metadata = None
-        mcp_server_configs = []
         resource_configs = []
 
-    # Auto-detect local MCP server if not explicitly configured
-    # This makes mcp_servers config optional - agents get tools automatically
-    # But if mcp_servers: [] is explicitly set, respect that (no auto-detection)
-    if not mcp_server_configs and not mcp_servers_explicitly_set:
-        import importlib
-        import os
-        import sys
-
-        # Ensure current working directory is in sys.path for local imports
-        cwd = os.getcwd()
-        if cwd not in sys.path:
-            sys.path.insert(0, cwd)
-
-        # Try common local MCP server module paths first
-        auto_detect_modules = [
-            "tools.mcp_server",  # Convention: tools/mcp_server.py
-            "mcp_server",        # Alternative: mcp_server.py in root
-        ]
-        for module_path in auto_detect_modules:
-            try:
-                mcp_module = importlib.import_module(module_path)
-                if hasattr(mcp_module, "mcp"):
-                    logger.info(f"Auto-detected local MCP server: {module_path}")
-                    mcp_server_configs = [{"type": "local", "module": module_path, "id": "auto-detected"}]
-                    break
-            except ImportError:
-                continue
-
-        # Fall back to REM's default MCP server if no local server found
-        if not mcp_server_configs:
-            logger.debug("No local MCP server found, using REM default")
-            mcp_server_configs = [{"type": "local", "module": "rem.mcp_server", "id": "rem"}]
+    # Auto-detect MCP server at application level
+    # Convention: tools/mcp_server.py exports `mcp` FastMCP instance
+    # Falls back to REM's built-in MCP server if no local server found
+    import importlib
+    import os
+    import sys
+
+    # Ensure current working directory is in sys.path for local imports
+    cwd = os.getcwd()
+    if cwd not in sys.path:
+        sys.path.insert(0, cwd)
+
+    mcp_server_configs = []
+    auto_detect_modules = [
+        "tools.mcp_server",  # Convention: tools/mcp_server.py
+        "mcp_server",        # Alternative: mcp_server.py in root
+    ]
+    for module_path in auto_detect_modules:
+        try:
+            mcp_module = importlib.import_module(module_path)
+            if hasattr(mcp_module, "mcp"):
+                logger.info(f"Auto-detected local MCP server: {module_path}")
+                mcp_server_configs = [{"type": "local", "module": module_path, "id": "auto-detected"}]
+                break
+        except ImportError as e:
+            logger.debug(f"MCP server auto-detect: {module_path} not found ({e})")
+            continue
+        except Exception as e:
+            logger.warning(f"MCP server auto-detect: {module_path} failed to load: {e}")
+            continue
+
+    # Fall back to REM's default MCP server if no local server found
+    if not mcp_server_configs:
+        logger.info("No local MCP server found, using REM default (rem.mcp_server)")
+        mcp_server_configs = [{"type": "local", "module": "rem.mcp_server", "id": "rem"}]
 
     # Extract temperature and max_iterations from schema metadata (with fallback to settings defaults)
     if metadata:
@@ -730,7 +732,7 @@ async def create_agent(
     # the artificial MCP distinction between tools and resources
     #
     # Supports both concrete and template URIs:
-    # - Concrete: "rem://schemas" -> no-param tool
+    # - Concrete: "rem://agents" -> no-param tool
     # - Template: "patient-profile://field/{field_key}" -> tool with field_key param
     from ..mcp.tool_wrapper import create_resource_tool
 
@@ -766,6 +768,7 @@ async def create_agent(
 
     # Create tools from collected resource URIs
     # Pass the loaded MCP server so resources can be resolved from it
+    logger.info(f"Creating {len(resource_uris)} resource tools with mcp_server={'set' if loaded_mcp_server else 'None'}")
     for uri, usage in resource_uris:
         resource_tool = create_resource_tool(uri, usage, mcp_server=loaded_mcp_server)
         tools.append(resource_tool)

rem/agentic/schema.py

@@ -79,7 +79,7 @@ class MCPResourceReference(BaseModel):
 
     Example (exact URI):
         {
-            "uri": "rem://schemas",
+            "uri": "rem://agents",
             "name": "Agent Schemas",
             "description": "List all available agent schemas"
         }
@@ -96,7 +96,7 @@ class MCPResourceReference(BaseModel):
         default=None,
         description=(
             "Exact resource URI or URI with query parameters. "
-            "Examples: 'rem://schemas', 'rem://resources?category=drug.*'"
+            "Examples: 'rem://agents', 'rem://resources?category=drug.*'"
         )
     )
 

rem/agentic/tools/rem_tools.py

@@ -3,6 +3,17 @@ REM tools for agent execution (CLI and API compatible).
 
 These tools work in both CLI and API contexts by initializing services on-demand.
 They wrap the service layer directly, not MCP tools.
+
+Core tables (always available):
+- resources: Documents, content chunks, artifacts
+- moments: Temporal narratives extracted from resources (usually user-specific)
+- ontologies: Domain entities with semantic links for further lookups (like a wiki)
+
+Other tables (may vary by deployment):
+- users, sessions, messages, files, schemas, feedbacks
+
+Note: Not all tables are populated in all systems. Use FUZZY or SEARCH
+to discover what data exists before assuming specific tables have content.
 """
 
 from typing import Any, Literal, cast

rem/api/main.py

@@ -322,7 +322,7 @@ def create_app() -> FastAPI:
 
     app.add_middleware(
         AuthMiddleware,
-        protected_paths=["/api/v1"],
+        protected_paths=["/api/v1", "/api/admin"],
         excluded_paths=["/api/auth", "/api/dev", "/api/v1/mcp/auth", "/api/v1/slack"],
         # Allow anonymous when auth is disabled, otherwise use setting
         allow_anonymous=(not settings.auth.enabled) or settings.auth.allow_anonymous,

rem/api/mcp_router/resources.py

@@ -349,6 +349,53 @@ def register_agent_resources(mcp: FastMCP):
         except Exception as e:
             return f"# Available Agents\n\nError listing agents: {e}"
 
+    @mcp.resource("rem://agents/{agent_name}")
+    def get_agent_schema(agent_name: str) -> str:
+        """
+        Get a specific agent schema by name.
+
+        Args:
+            agent_name: Name of the agent (e.g., "ask_rem", "agent-builder")
+
+        Returns:
+            Full agent schema as YAML string, or error message if not found.
+        """
+        import importlib.resources
+        import yaml
+        from pathlib import Path
+
+        try:
+            # Find packaged agent schemas
+            agents_ref = importlib.resources.files("rem") / "schemas" / "agents"
+            agents_dir = Path(str(agents_ref))
+
+            if not agents_dir.exists():
+                return f"# Agent Not Found\n\nNo agent schemas directory found."
+
+            # Search for agent file (try multiple extensions)
+            for ext in [".yaml", ".yml", ".json"]:
+                # Try exact match first
+                agent_file = agents_dir / f"{agent_name}{ext}"
+                if agent_file.exists():
+                    with open(agent_file, "r") as f:
+                        content = f.read()
+                    return f"# Agent Schema: {agent_name}\n\n```yaml\n{content}\n```"
+
+                # Try recursive search
+                matches = list(agents_dir.rglob(f"{agent_name}{ext}"))
+                if matches:
+                    with open(matches[0], "r") as f:
+                        content = f.read()
+                    return f"# Agent Schema: {agent_name}\n\n```yaml\n{content}\n```"
+
+            # Not found - list available agents
+            available = [f.stem for f in agents_dir.rglob("*.yaml")] + \
+                       [f.stem for f in agents_dir.rglob("*.yml")]
+            return f"# Agent Not Found\n\nAgent '{agent_name}' not found.\n\nAvailable agents: {', '.join(sorted(set(available)))}"
+
+        except Exception as e:
+            return f"# Error\n\nError loading agent '{agent_name}': {e}"
+
 
 def register_file_resources(mcp: FastMCP):
     """
@@ -501,10 +548,11 @@ async def load_resource(uri: str) -> dict | str:
     Load an MCP resource by URI.
 
     This function is called by the read_resource tool to dispatch to
-    registered resource handlers.
+    registered resource handlers. Supports both regular resources and
+    parameterized resource templates (e.g., rem://agents/{agent_name}).
 
     Args:
-        uri: Resource URI (e.g., "rem://schemas", "rem://status")
+        uri: Resource URI (e.g., "rem://agents", "rem://agents/ask_rem", "rem://status")
 
     Returns:
         Resource data (dict or string)
@@ -524,18 +572,26 @@ async def load_resource(uri: str) -> dict | str:
     register_file_resources(mcp)
     register_status_resources(mcp)
 
-    # Get resources using FastMCP's async get_resources() method
+    # 1. Try exact match in regular resources
     resources = await mcp.get_resources()
-
     if uri in resources:
         resource = resources[uri]
-        # Call the underlying function
         result = resource.fn()
-        # Handle async functions
         if inspect.iscoroutine(result):
             result = await result
         return result if result else {"error": "Resource returned None"}
 
-    # If not found, raise error
-    available = list(resources.keys())
+    # 2. Try matching against parameterized resource templates
+    templates = await mcp.get_resource_templates()
+    for template_uri, template in templates.items():
+        params = template.matches(uri)
+        if params is not None:
+            # Template matched - call function with extracted parameters
+            result = template.fn(**params)
+            if inspect.iscoroutine(result):
+                result = await result
+            return result if result else {"error": "Resource returned None"}
+
+    # 3. Not found - include both resources and templates in error
+    available = list(resources.keys()) + list(templates.keys())
     raise ValueError(f"Resource not found: {uri}. Available resources: {available}")

rem/api/mcp_router/server.py

@@ -1,7 +1,7 @@
 """
 MCP server creation and configuration for REM.
 
-Design Pattern 
+Design Pattern
 1. Create FastMCP server with tools and resources
 2. Register tools using @mcp.tool() decorator
 3. Register resources using resource registration functions
@@ -20,10 +20,31 @@ FastMCP Features:
 """
 
 import importlib.metadata
+from functools import wraps
 
 from fastmcp import FastMCP
+from loguru import logger
 
 from ...settings import settings
+from .prompts import register_prompts
+from .resources import (
+    register_agent_resources,
+    register_file_resources,
+    register_schema_resources,
+    register_status_resources,
+)
+from .tools import (
+    ask_agent,
+    ask_rem_agent,
+    get_schema,
+    ingest_into_rem,
+    list_schema,
+    read_resource,
+    register_metadata,
+    save_agent,
+    search_rem,
+    test_error_handling,
+)
 
 # Get package version
 try:
@@ -174,18 +195,7 @@ def create_mcp_server(is_local: bool = False) -> FastMCP:
         ),
     )
 
-    # Register REM tools
-    from .tools import (
-        ask_rem_agent,
-        get_schema,
-        ingest_into_rem,
-        list_schema,
-        read_resource,
-        register_metadata,
-        save_agent,
-        search_rem,
-    )
-
+    # Register core REM tools
     mcp.tool()(search_rem)
     mcp.tool()(ask_rem_agent)
     mcp.tool()(read_resource)
@@ -194,10 +204,16 @@ def create_mcp_server(is_local: bool = False) -> FastMCP:
     mcp.tool()(get_schema)
     mcp.tool()(save_agent)
 
+    # Register multi-agent tools
+    mcp.tool()(ask_agent)
+
+    # Register test tool only in development environment (not staging/production)
+    if settings.environment not in ("staging", "production"):
+        mcp.tool()(test_error_handling)
+        logger.debug("Registered test_error_handling tool (dev environment only)")
+
     # File ingestion tool (with local path support for local servers)
     # Wrap to inject is_local parameter
-    from functools import wraps
-
     @wraps(ingest_into_rem)
     async def ingest_into_rem_wrapper(
         file_uri: str,
@@ -216,18 +232,9 @@ def create_mcp_server(is_local: bool = False) -> FastMCP:
     mcp.tool()(ingest_into_rem_wrapper)
 
     # Register prompts
-    from .prompts import register_prompts
-
     register_prompts(mcp)
 
     # Register schema resources
-    from .resources import (
-        register_agent_resources,
-        register_file_resources,
-        register_schema_resources,
-        register_status_resources,
-    )
-
     register_schema_resources(mcp)
     register_agent_resources(mcp)
     register_file_resources(mcp)