adapt-server 0.2.3__tar.gz → 0.2.4__tar.gz

{adapt_server-0.2.3 → adapt_server-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: adapt-server
-Version: 0.2.3
+Version: 0.2.4
 Summary: Adaptive file-backed FastAPI server that turns datasets into CRUD APIs and UIs.
 Author-email: notesofcliff <notesofcliff@gmail.com>
 License-Expression: MIT
@@ -21,7 +21,7 @@ Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: fastapi
+Requires-Dist: fastapi>=0.115
 Requires-Dist: uvicorn
 Requires-Dist: sqlmodel
 Requires-Dist: pendulum
@@ -36,6 +36,7 @@ Requires-Dist: pillow
 Requires-Dist: python-json-logger
 Requires-Dist: pandas
 Requires-Dist: fastparquet
+Requires-Dist: mcp<2,>=1.28
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: httpx; extra == "dev"
@@ -51,6 +52,8 @@ Adapt is a FastAPI server that turns files in a directory into APIs and UIs.
 - Markdown/HTML become browsable pages
 - Media files become streaming endpoints and player/gallery UIs
 - Python files can register custom routers
+- Everything is searchable in one place via full-text `/search`
+- Everything is reachable by agentic tools via an MCP server at `/mcp`
 
 ## Quick Start
 
@@ -81,6 +84,8 @@ Useful URLs:
 - `/api/<resource>` resource API
 - `/ui/<resource>` resource UI
 - `/schema/<resource>` resource schema
+- `/search` full-text search across every resource you can read
+- `/mcp` MCP server for agentic tools (see [MCP Interface](#mcp-interface) below)
 
 ## What Adapt Generates
 
@@ -135,6 +140,73 @@ This reflects the current implementation in the codebase.
 - Caching with invalidation on mutations
 - Built-in admin UI for users/groups/permissions/locks/cache/api keys/audit logs
 - Plugin architecture with companion overrides in `.adapt/`
+- Permission-filtered full-text search across every resource type
+- MCP server for agentic tool access, mounted alongside the REST API
+
+## Full-Text Search
+
+`GET /search?q=<query>` searches datasets, Markdown, HTML, and media metadata
+in one ranked list, filtered to what the caller may read — a query term that
+matches a resource you can't see never shows up, and never leaks via the
+result count either.
+
+```bash
+curl -H "X-API-Key: <key>" "http://localhost:8000/search?q=parental+leave"
+```
+
+The index refreshes incrementally on startup (`search_on_startup`, default
+`true`) and can be rebuilt on demand with `adapt reindex <root>`. See the
+[API Reference](docs/manual/api_reference.md#search-endpoint) for query
+parameters and result shape.
+
+## MCP Interface
+
+Adapt mounts a [Model Context Protocol](https://modelcontextprotocol.io)
+server at `/mcp`, on the same host/port as everything else, exposing five
+tools that wrap the same permission checks and plugin methods as the REST
+API — `list_resources`, `get_schema`, `read_resource`, `write_resource`, and
+`search`. There's no separate process, no separate API surface, and no
+extra permission model to maintain.
+
+Minimal walkthrough — create an account for the agent, grant it read access,
+mint an API key, and connect a client:
+
+```bash
+adapt addsuperuser /path/to/docroot --username admin
+adapt serve /path/to/docroot &
+
+adapt admin create-permissions /path/to/docroot __all__
+adapt admin create-user /path/to/docroot --username agent --password <strong-password>
+adapt admin add-to-group /path/to/docroot --username agent --group <resource>_readonly
+```
+
+Log in as `agent` and self-issue an API key from `/profile` (any
+authenticated user can create their own key — no superuser needed), then
+point a client at `/mcp` with that key:
+
+```bash
+# Claude Code CLI
+claude mcp add --transport http adapt http://localhost:8000/mcp \
+  --header "X-API-Key: <key>"
+```
+
+```json
+// Generic MCP client config (Claude Desktop and similar)
+{
+  "mcpServers": {
+    "adapt": {
+      "url": "http://localhost:8000/mcp",
+      "headers": { "X-API-Key": "<key>" }
+    }
+  }
+}
+```
+
+MCP requires an API key on every call — there's no session-cookie or
+anonymous path, since MCP has no concept of a browser session. Set
+`mcp_enabled: false` in `.adapt/conf.json` (or `ADAPT_MCP_ENABLED=false`) to
+remove `/mcp` entirely. Full walkthrough, troubleshooting, and the tool
+reference table: [docs/manual/mcp_guide.md](docs/manual/mcp_guide.md).
 
 ## Dataset Mutation Envelope
 
@@ -156,6 +228,7 @@ adapt serve <root> [--host ... --port ... --tls-cert ... --tls-key ... --reload
 adapt check <root>
 adapt addsuperuser <root> --username <name>
 adapt list-endpoints <root>
+adapt reindex <root> [--force]
 adapt admin list-resources <root>
 adapt admin create-permissions <root> __all__
 ```
@@ -169,6 +242,7 @@ Detailed docs live under `docs/manual/`.
 - Quick start: [docs/manual/quick_start.md](docs/manual/quick_start.md)
 - Configuration: [docs/manual/configuration.md](docs/manual/configuration.md)
 - API reference: [docs/manual/api_reference.md](docs/manual/api_reference.md)
+- MCP guide: [docs/manual/mcp_guide.md](docs/manual/mcp_guide.md)
 - Plugin development: [docs/manual/plugin_development.md](docs/manual/plugin_development.md)
 
 ## License

{adapt_server-0.2.3 → adapt_server-0.2.4}/README.md

@@ -6,6 +6,8 @@ Adapt is a FastAPI server that turns files in a directory into APIs and UIs.
 - Markdown/HTML become browsable pages
 - Media files become streaming endpoints and player/gallery UIs
 - Python files can register custom routers
+- Everything is searchable in one place via full-text `/search`
+- Everything is reachable by agentic tools via an MCP server at `/mcp`
 
 ## Quick Start
 
@@ -36,6 +38,8 @@ Useful URLs:
 - `/api/<resource>` resource API
 - `/ui/<resource>` resource UI
 - `/schema/<resource>` resource schema
+- `/search` full-text search across every resource you can read
+- `/mcp` MCP server for agentic tools (see [MCP Interface](#mcp-interface) below)
 
 ## What Adapt Generates
 
@@ -90,6 +94,73 @@ This reflects the current implementation in the codebase.
 - Caching with invalidation on mutations
 - Built-in admin UI for users/groups/permissions/locks/cache/api keys/audit logs
 - Plugin architecture with companion overrides in `.adapt/`
+- Permission-filtered full-text search across every resource type
+- MCP server for agentic tool access, mounted alongside the REST API
+
+## Full-Text Search
+
+`GET /search?q=<query>` searches datasets, Markdown, HTML, and media metadata
+in one ranked list, filtered to what the caller may read — a query term that
+matches a resource you can't see never shows up, and never leaks via the
+result count either.
+
+```bash
+curl -H "X-API-Key: <key>" "http://localhost:8000/search?q=parental+leave"
+```
+
+The index refreshes incrementally on startup (`search_on_startup`, default
+`true`) and can be rebuilt on demand with `adapt reindex <root>`. See the
+[API Reference](docs/manual/api_reference.md#search-endpoint) for query
+parameters and result shape.
+
+## MCP Interface
+
+Adapt mounts a [Model Context Protocol](https://modelcontextprotocol.io)
+server at `/mcp`, on the same host/port as everything else, exposing five
+tools that wrap the same permission checks and plugin methods as the REST
+API — `list_resources`, `get_schema`, `read_resource`, `write_resource`, and
+`search`. There's no separate process, no separate API surface, and no
+extra permission model to maintain.
+
+Minimal walkthrough — create an account for the agent, grant it read access,
+mint an API key, and connect a client:
+
+```bash
+adapt addsuperuser /path/to/docroot --username admin
+adapt serve /path/to/docroot &
+
+adapt admin create-permissions /path/to/docroot __all__
+adapt admin create-user /path/to/docroot --username agent --password <strong-password>
+adapt admin add-to-group /path/to/docroot --username agent --group <resource>_readonly
+```
+
+Log in as `agent` and self-issue an API key from `/profile` (any
+authenticated user can create their own key — no superuser needed), then
+point a client at `/mcp` with that key:
+
+```bash
+# Claude Code CLI
+claude mcp add --transport http adapt http://localhost:8000/mcp \
+  --header "X-API-Key: <key>"
+```
+
+```json
+// Generic MCP client config (Claude Desktop and similar)
+{
+  "mcpServers": {
+    "adapt": {
+      "url": "http://localhost:8000/mcp",
+      "headers": { "X-API-Key": "<key>" }
+    }
+  }
+}
+```
+
+MCP requires an API key on every call — there's no session-cookie or
+anonymous path, since MCP has no concept of a browser session. Set
+`mcp_enabled: false` in `.adapt/conf.json` (or `ADAPT_MCP_ENABLED=false`) to
+remove `/mcp` entirely. Full walkthrough, troubleshooting, and the tool
+reference table: [docs/manual/mcp_guide.md](docs/manual/mcp_guide.md).
 
 ## Dataset Mutation Envelope
 
@@ -111,6 +182,7 @@ adapt serve <root> [--host ... --port ... --tls-cert ... --tls-key ... --reload
 adapt check <root>
 adapt addsuperuser <root> --username <name>
 adapt list-endpoints <root>
+adapt reindex <root> [--force]
 adapt admin list-resources <root>
 adapt admin create-permissions <root> __all__
 ```
@@ -124,6 +196,7 @@ Detailed docs live under `docs/manual/`.
 - Quick start: [docs/manual/quick_start.md](docs/manual/quick_start.md)
 - Configuration: [docs/manual/configuration.md](docs/manual/configuration.md)
 - API reference: [docs/manual/api_reference.md](docs/manual/api_reference.md)
+- MCP guide: [docs/manual/mcp_guide.md](docs/manual/mcp_guide.md)
 - Plugin development: [docs/manual/plugin_development.md](docs/manual/plugin_development.md)
 
 ## License

{adapt_server-0.2.3 → adapt_server-0.2.4}/adapt/__init__.py

@@ -1,3 +1,3 @@
 """Adapt package namespace."""
 
-__version__ = "0.2.3"
+__version__ = "0.2.4"

{adapt_server-0.2.3 → adapt_server-0.2.4}/adapt/admin/ui.py

@@ -30,4 +30,4 @@ def admin_ui(request: Request):
 
     # Serve the admin template
     logger.debug("Rendering admin UI for superuser %s", user.username)
-    return request.app.state.templates.TemplateResponse("admin/index.html", context)
+    return request.app.state.templates.TemplateResponse(request, "admin/index.html", context)

{adapt_server-0.2.3 → adapt_server-0.2.4}/adapt/app.py

@@ -12,7 +12,6 @@ from fastapi.openapi.docs import get_swagger_ui_html, get_swagger_ui_oauth2_redi
 from fastapi.openapi.utils import get_openapi
 from fastapi.responses import JSONResponse, RedirectResponse
 from fastapi.middleware.trustedhost import TrustedHostMiddleware
-from fastapi.routing import APIRoute
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
 from sqlmodel import Session, select, delete
@@ -25,11 +24,13 @@ from .admin import router as admin_router
 from .config import AdaptConfig
 from .discovery import discover_resources
 from .permissions import PermissionChecker
-from .routes import generate_routes
+from .routes import build_resource_registry, generate_routes, resource_namespaces as _routes_resource_namespaces
+from .routes_search import router as search_router, safe_snippet
 from .storage import User, DBSession, init_database
 from .locks import LockManager
+from .mcp import build_mcp_server
 from .utils import build_accessible_ui_links
-from . import cache
+from . import cache, search
 from .security import (
     apply_security_headers,
     build_allowed_hosts,
@@ -45,7 +46,7 @@ logger = logging.getLogger(__name__)
 
 _DOCS_INTERNAL_PATHS = frozenset({"/docs", "/docs/", "/docs/oauth2-redirect", "/openapi.json"})
 _PUBLIC_OPENAPI_PATHS = frozenset({"/", "/auth/login", "/health"})
-_AUTHENTICATED_OPENAPI_PATHS = frozenset({"/auth/logout", "/auth/me", "/profile", "/api/apikeys"})
+_AUTHENTICATED_OPENAPI_PATHS = frozenset({"/auth/logout", "/auth/me", "/profile", "/api/apikeys", "/search"})
 
 
 async def cleanup_expired_sessions(engine, interval_hours=24):
@@ -72,13 +73,7 @@ def _normalize_path(path: str) -> str:
 
 def _resource_namespaces(resource) -> set[str]:
     """Return the supported permission namespaces for a discovered resource."""
-    namespace_no_ext = resource.relative_path.with_suffix("").as_posix()
-    namespace_with_ext = resource.relative_path.as_posix()
-    if "sub_namespace" in resource.metadata:
-        suffix = f"/{resource.metadata['sub_namespace']}"
-        namespace_no_ext += suffix
-        namespace_with_ext += suffix
-    return {namespace_no_ext, namespace_with_ext}
+    return set(_routes_resource_namespaces(resource))
 
 
 def _all_resource_namespaces(resources) -> set[str]:
@@ -125,14 +120,14 @@ def _extract_resource_namespace(path: str, all_namespaces: set[str]) -> str | No
     return None
 
 
-def _route_is_visible(route: APIRoute, request: Request, user: User | None, all_namespaces: set[str], visible_namespaces: set[str]) -> bool:
-    """Decide whether a route should appear in the current request's OpenAPI schema."""
-    path = _normalize_path(route.path)
+def _operation_is_visible(path: str, operation: dict, request: Request, user: User | None, all_namespaces: set[str], visible_namespaces: set[str]) -> bool:
+    """Decide whether an OpenAPI operation should appear in the current request's schema."""
+    path = _normalize_path(path)
 
     if path in _DOCS_INTERNAL_PATHS:
         return False
 
-    if path.startswith("/admin") or "admin" in (route.tags or []):
+    if path.startswith("/admin") or "admin" in (operation.get("tags") or []):
         return bool(user and getattr(user, "is_superuser", False))
 
     if path in _PUBLIC_OPENAPI_PATHS:
@@ -160,24 +155,73 @@ def _route_is_visible(route: APIRoute, request: Request, user: User | None, all_
     return False
 
 
+def _iter_schema_refs(node):
+    """Yield component schema names referenced anywhere within a JSON-like node."""
+    if isinstance(node, dict):
+        ref = node.get("$ref")
+        if isinstance(ref, str) and ref.startswith("#/components/schemas/"):
+            yield ref.removeprefix("#/components/schemas/")
+        for value in node.values():
+            yield from _iter_schema_refs(value)
+    elif isinstance(node, list):
+        for item in node:
+            yield from _iter_schema_refs(item)
+
+
+def _prune_unreferenced_components(schema: dict) -> None:
+    """Drop component schemas no longer reachable from any kept path.
+
+    Filtering removes paths but leaves their request/response models behind in
+    components.schemas — a non-superuser would otherwise receive the
+    field-level shape of admin-only models like UserPublic or Permission.
+    """
+    components = schema.get("components") or {}
+    schemas = components.get("schemas")
+    if not schemas:
+        return
+
+    reachable: set[str] = set()
+    pending = set(_iter_schema_refs(schema.get("paths", {})))
+    while pending:
+        name = pending.pop()
+        if name in reachable:
+            continue
+        reachable.add(name)
+        pending.update(_iter_schema_refs(schemas.get(name, {})))
+
+    pruned = {name: definition for name, definition in schemas.items() if name in reachable}
+    if pruned:
+        components["schemas"] = pruned
+    else:
+        components.pop("schemas", None)
+    if not components:
+        schema.pop("components", None)
+
+
 def _build_openapi_schema(app: FastAPI, request: Request, user: User | None) -> dict:
     """Build a filtered OpenAPI schema for the current request context."""
-    all_namespaces = _all_resource_namespaces(request.app.state.resources)
-    visible_namespaces = _visible_resource_namespaces(request, user)
-    visible_routes = [
-        route
-        for route in app.routes
-        if isinstance(route, APIRoute)
-        and route.include_in_schema
-        and _route_is_visible(route, request, user, all_namespaces, visible_namespaces)
-    ]
-
-    return get_openapi(
+    schema = get_openapi(
         title=app.title,
         version=app.version,
         description=app.description,
-        routes=visible_routes,
+        routes=app.routes,
     )
+    all_namespaces = _all_resource_namespaces(request.app.state.resources)
+    visible_namespaces = _visible_resource_namespaces(request, user)
+
+    visible_paths: dict[str, dict] = {}
+    for path, operations in schema.get("paths", {}).items():
+        kept = {
+            method: operation
+            for method, operation in operations.items()
+            if _operation_is_visible(path, operation, request, user, all_namespaces, visible_namespaces)
+        }
+        if kept:
+            visible_paths[path] = kept
+
+    schema["paths"] = visible_paths
+    _prune_unreferenced_components(schema)
+    return schema
 
 
 def _visible_resource_paths(request: Request, user: User | None) -> list[str]:
@@ -192,14 +236,25 @@ def _visible_resource_paths(request: Request, user: User | None) -> list[str]:
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    """Handle application startup and shutdown events."""
+    """Handle application startup and shutdown events.
+
+    A mounted MCP sub-app's own `lifespan` is never invoked by the ASGI
+    server: Starlette's `Mount` only forwards `http`/`websocket` scope types,
+    never `lifespan`. So the MCP session manager's `run()` context must be
+    entered here, alongside the rest of this app's own startup/shutdown.
+    """
     # Startup: Start background cleanup task
     engine = app.state.db_engine
     cleanup_task = asyncio.create_task(cleanup_expired_sessions(engine))
     logger.debug("Application startup: background cleanup task started")
-    
-    yield
-    
+
+    mcp_server = getattr(app.state, "mcp_server", None)
+    if mcp_server is not None:
+        async with mcp_server.session_manager.run():
+            yield
+    else:
+        yield
+
     # Shutdown: Could add cleanup logic here if needed
     cleanup_task.cancel()
     try:
@@ -219,12 +274,16 @@ def _init_infrastructure(config: AdaptConfig):
     """
     engine = init_database(config.db_path)
     cache.configure(str(config.db_path))
+    search.configure(str(config.db_path))
     lock_manager = LockManager(engine)
     cleaned = lock_manager.release_stale_locks(max_age_seconds=300)
     if cleaned > 0:
         logging.warning("Cleaned %d stale locks on startup", cleaned)
     resources = discover_resources(config.root, config)
     logger.debug("Discovered %d resources", len(resources))
+    if config.search_on_startup:
+        # Incremental: unchanged files are skipped, so restarts stay cheap.
+        search.reindex_all(resources, config)
     return engine, lock_manager, resources
 
 
@@ -246,6 +305,7 @@ def create_app(config: AdaptConfig) -> FastAPI:
     app.state.use_tls = bool(config.tls_cert and config.tls_key)
     app.state.lock_manager = lock_manager
     app.state.resources = resources
+    app.state.resource_registry = build_resource_registry(resources, config)
 
     allowed_hosts = build_allowed_hosts(config.host)
     if allowed_hosts != ["*"]:
@@ -254,6 +314,9 @@ def create_app(config: AdaptConfig) -> FastAPI:
     # Set up Jinja2 templates
     templates_dir = Path(__file__).parent / "templates"
     templates = Jinja2Templates(directory=str(templates_dir))
+    # Search snippets hold raw docroot text; this escapes them and restores only
+    # the <mark> highlights. See routes_search.safe_snippet.
+    templates.env.filters["safe_snippet"] = safe_snippet
     app.state.templates = templates
 
     # Mount static files
@@ -310,8 +373,32 @@ def create_app(config: AdaptConfig) -> FastAPI:
     # Mount admin routes
     app.include_router(admin_router)
 
+    # Mount search routes
+    app.include_router(search_router)
+
     # Generate and mount routes
-    generate_routes(app, resources, config)
+    generate_routes(app, app.state.resource_registry)
+
+    # Mount the MCP server, exposing resources as agent-facing tools
+    if config.mcp_enabled:
+        mcp_server = build_mcp_server(config)
+        mcp_app = mcp_server.streamable_http_app()
+        # A mounted sub-app's `request.app` is itself, not the main app (see
+        # lifespan() docstring for the related lifespan gotcha) — mirror the
+        # slice of state every tool/helper needs onto it.
+        mcp_app.state.db_engine = engine
+        mcp_app.state.resources = resources
+        mcp_app.state.config = config
+        mcp_app.state.lock_manager = lock_manager
+        mcp_app.state.resource_registry = app.state.resource_registry
+        # The outer app's own middleware still runs for /mcp requests (it wraps
+        # routing, including the Mount), and by the time it inspects
+        # `request.app.state` post-routing, `scope["app"]` has already been
+        # overwritten to `mcp_app` — so anything that middleware reads off
+        # app.state must be mirrored here too, not just what the tools need.
+        mcp_app.state.use_tls = app.state.use_tls
+        app.state.mcp_server = mcp_server
+        app.mount("/mcp", mcp_app)
 
     @app.get("/openapi.json", include_in_schema=False)
     def openapi_schema(request: Request):

{adapt_server-0.2.3 → adapt_server-0.2.4}/adapt/cli.py

@@ -7,7 +7,7 @@ import logging.config
 from pathlib import Path
 
 from .config import AdaptConfig
-from .commands import check, addsuperuser, list_endpoints, serve
+from .commands import check, addsuperuser, list_endpoints, reindex, serve
 from .commands.admin import run_admin
 
 logger = logging.getLogger(__name__)
@@ -40,6 +40,10 @@ def main() -> None:
     list_parser = subparsers.add_parser("list-endpoints", help="List the auto-generated REST/UI endpoints")
     list_parser.add_argument("root", nargs="?", default=".", help="Document root to inspect")
 
+    reindex_parser = subparsers.add_parser("reindex", help="Rebuild the full-text search index")
+    reindex_parser.add_argument("root", nargs="?", default=".", help="Document root to index")
+    reindex_parser.add_argument("--force", action="store_true", help="Reindex even unchanged files")
+
     admin_parser = subparsers.add_parser("admin", help="Admin tasks")
     admin_subparsers = admin_parser.add_subparsers(dest="admin_command", required=True)
     admin_list_resources_parser = admin_subparsers.add_parser("list-resources", help="List discovered resources")
@@ -116,6 +120,9 @@ def main() -> None:
     elif args.command == "list-endpoints":
         logger.info("Running list-endpoints command with root=%s", args.root)
         list_endpoints.run_list_endpoints(Path(args.root).resolve())
+    elif args.command == "reindex":
+        logger.info("Running reindex command with root=%s force=%s", args.root, args.force)
+        reindex.run_reindex(Path(args.root).resolve(), force=args.force)
     elif args.command == "admin":
         logger.info("Running admin command: %s", args.admin_command)
         run_admin(args)

{adapt_server-0.2.3 → adapt_server-0.2.4}/adapt/commands/check.py

@@ -8,6 +8,12 @@ from .. import cache
 
 logger = logging.getLogger(__name__)
 
+# Namespaces claimed by built-in routes. A markdown or HTML file with one of
+# these names mounts at the same path and shadows the built-in.
+RESERVED_NAMESPACES = frozenset({
+    "search", "health", "profile", "admin", "docs", "static", "openapi.json",
+})
+
 
 def run_check(root: Path) -> None:
     """Check the configuration and discover resources.
@@ -31,6 +37,16 @@ def run_check(root: Path) -> None:
     print(f"Document root: {config.root}")
     print(f"SQLite store: {config.db_path} (engine {engine})")
     print(f"Discovered {count} dataset(s)")
+
+    # Markdown and HTML resources mount at /<namespace>, so they can collide
+    # with built-in routes; datasets live under /api and /ui and cannot.
+    for resource in resources:
+        if resource.resource_type not in ("markdown", "html"):
+            continue
+        namespace = resource.relative_path.with_suffix("").as_posix()
+        if namespace in RESERVED_NAMESPACES:
+            logger.warning("Resource %s shadows the built-in /%s route", resource.path, namespace)
+            print(f"WARNING: {resource.relative_path} shadows the built-in /{namespace} route")
     # Validate TLS if configured
     if config.tls_cert or config.tls_key:
         if config.tls_cert and not config.tls_cert.exists():

adapt_server-0.2.4/adapt/commands/reindex.py

@@ -0,0 +1,44 @@
+from pathlib import Path
+import logging
+
+from ..config import AdaptConfig
+from ..discovery import discover_resources
+from ..storage import init_database
+from .. import cache, search
+
+logger = logging.getLogger(__name__)
+
+
+def run_reindex(root: Path, force: bool = False) -> None:
+    """Rebuild the full-text search index for a document root.
+
+    The index normally refreshes on server startup. Run this to rebuild it
+    without starting the server, or with `force` after changing how a plugin
+    produces documents, since incremental refresh keys only on file mtime and
+    size and would otherwise skip unchanged files.
+
+    Args:
+        root: The document root to index.
+        force: Reindex every resource, even ones that appear unchanged.
+    """
+    config = AdaptConfig(root=root)
+    config.load_from_file()
+    init_database(config.db_path)
+    cache.configure(str(config.db_path))
+    search.configure(str(config.db_path))
+
+    if not search.is_available():
+        logger.error("Search index unavailable: this SQLite build lacks FTS5")
+        print("Search index unavailable: this SQLite build lacks FTS5.")
+        return
+
+    resources = discover_resources(config.root, config)
+    stats = search.reindex_all(resources, config, force=force)
+
+    print(f"Document root: {config.root}")
+    print(f"Search index: {config.db_path}")
+    print(
+        f"Indexed {stats['indexed']} resource(s) "
+        f"({stats['documents']} document(s)), "
+        f"skipped {stats['skipped']}, pruned {stats['pruned']}"
+    )

{adapt_server-0.2.3 → adapt_server-0.2.4}/adapt/config.py

@@ -36,6 +36,8 @@ class AdaptConfig:
     tls_cert: Path | None = None
     tls_key: Path | None = None
     secure_cookies: bool = False  # Whether to set secure flag on cookies
+    search_on_startup: bool = True  # Whether to refresh the search index on startup
+    mcp_enabled: bool = True  # Whether to mount the MCP server at /mcp
     plugin_registry: dict[str, str] = field(default_factory=lambda: {
         ".csv": "adapt.plugins.csv_plugin.CsvPlugin",
         ".xlsx": "adapt.plugins.excel_plugin.ExcelPlugin",
@@ -139,8 +141,10 @@ class AdaptConfig:
             "tls_cert": str(self.tls_cert) if self.tls_cert else None,
             "tls_key": str(self.tls_key) if self.tls_key else None,
             "secure_cookies": self.secure_cookies,
+            "search_on_startup": self.search_on_startup,
             "readonly": self.readonly,
             "debug": self.debug,
+            "mcp_enabled": self.mcp_enabled,
             "logging": self.logging.copy(),
         }
         with conf_path.open("w") as f:
@@ -159,7 +163,8 @@ class AdaptConfig:
         """Validate all keys and types in the loaded config dict, exiting on error."""
         allowed_keys = {
             "plugin_registry", "host", "port", "tls_cert", "tls_key",
-            "secure_cookies", "readonly", "debug", "logging",
+            "secure_cookies", "search_on_startup", "readonly", "debug", "logging",
+            "mcp_enabled",
         }
         for key in data:
             if key not in allowed_keys:
@@ -192,7 +197,7 @@ class AdaptConfig:
             if not isinstance(data["tls_key"], str):
                 logger.error("tls_key must be str or null")
                 sys.exit(1)
-        for bool_key in ("secure_cookies", "readonly", "debug"):
+        for bool_key in ("secure_cookies", "search_on_startup", "readonly", "debug", "mcp_enabled"):
             if bool_key in data and not isinstance(data[bool_key], bool):
                 logger.error("%s must be bool", bool_key)
                 sys.exit(1)
@@ -214,10 +219,14 @@ class AdaptConfig:
             self.tls_key = Path(data["tls_key"])
         if "secure_cookies" in data:
             self.secure_cookies = data["secure_cookies"]
+        if "search_on_startup" in data:
+            self.search_on_startup = data["search_on_startup"]
         if "readonly" in data:
             self.readonly = data["readonly"]
         if "debug" in data:
             self.debug = data["debug"]
+        if "mcp_enabled" in data:
+            self.mcp_enabled = data["mcp_enabled"]
         if "logging" in data:
             self.logging.update(data["logging"])
 
@@ -239,3 +248,5 @@ class AdaptConfig:
             self.readonly = self._parse_env_bool(os.environ["ADAPT_READONLY"], "ADAPT_READONLY")
         if "ADAPT_DEBUG" in os.environ:
             self.debug = self._parse_env_bool(os.environ["ADAPT_DEBUG"], "ADAPT_DEBUG")
+        if "ADAPT_MCP_ENABLED" in os.environ:
+            self.mcp_enabled = self._parse_env_bool(os.environ["ADAPT_MCP_ENABLED"], "ADAPT_MCP_ENABLED")