graphharbor 0.13.0.post2__py3-none-any.whl

graphharbor-0.13.0.post2.dist-info/METADATA

@@ -0,0 +1,64 @@
+Metadata-Version: 2.5
+Name: graphharbor
+Version: 0.13.0.post2
+Summary: GraphHarbor CLI for a self-hosted LangGraph Agent Server on PostgreSQL and Redis
+Project-URL: Homepage, https://github.com/ljxpython/graphharbor
+Project-URL: Repository, https://github.com/ljxpython/graphharbor
+Project-URL: Issues, https://github.com/ljxpython/graphharbor/issues
+Project-URL: Changelog, https://github.com/ljxpython/graphharbor/releases
+Author-email: Mohankumar Ramachandran <mail@mohanram.dev>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agent-protocol,agent-server,agents,ai-agents,cli,langchain,langgraph,langgraph-api,langgraph-sdk,langsmith,llm,open-source,postgres,redis,self-hosted,uvicorn
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: click>=8.1.7
+Requires-Dist: graphharbor-runtime==0.13.0.post2
+Requires-Dist: langgraph-cli<0.5,>=0.4.0
+Requires-Dist: pyfiglet>=1.0.0
+Requires-Dist: python-dotenv>=0.8.0
+Requires-Dist: uvicorn[standard]>=0.51.0
+Description-Content-Type: text/markdown
+
+# graphharbor
+
+Minimal CLI for running the self-hosted GraphHarbor Agent Server on the open
+[`graphharbor-runtime`](https://pypi.org/project/graphharbor-runtime/) backend
+(Postgres + Redis).
+
+## Command
+
+```bash
+graphharbor serve [OPTIONS]
+```
+
+Requires a `langgraph.json` in the working directory (same format as
+[`langgraph-cli`](https://github.com/langchain-ai/langgraph/tree/main/libs/cli))
+and `DATABASE_URI` / `REDIS_URI` (see repo `.env.example`). Bring your own
+PostgreSQL and Redis reachable from the host.
+
+```bash
+cp .env.example .env
+# Start PostgreSQL and Redis with your host's service manager.
+
+# Dev (hot reload)
+graphharbor serve --reload -c langgraph.json
+
+# Prod (multi-process)
+graphharbor serve --host 0.0.0.0 --workers 4 -c langgraph.json
+```
+
+Run `graphharbor serve --help` for the full option list.

graphharbor-0.13.0.post2.dist-info/RECORD

@@ -0,0 +1,12 @@
+langhost/__init__.py,sha256=A3vk6inbe5N-v0ti0JoQoSAPMyiMy4YuCDYNOhiEz54,275
+langhost/__main__.py,sha256=Z_8g0qzCSaEiYYX5KPZ_0Q3YHN83PaSNYPW1op38meM,67
+langhost/cli.py,sha256=Bc2oL8aaCBdZSwN4zu-xKf9aPGzYAWflRlRMR_qWlkY,16664
+langhost/core_api.py,sha256=Uf73zDohE6V6YHcznVbxUEF2FAis78l8FPUneuf42EE,52111
+langhost/protocol_api.py,sha256=IXpKNMqhpPozSCN9BIGOzVz57gMoocKSwMZDqjhkTxM,13381
+langhost/server.py,sha256=Kts1cyNpZh9v_DjrOgANZp37cCqyFDFZlHEkLL6b5tY,35730
+langhost/streaming.py,sha256=a6g31tZ-MQ8m01Cl8s7pj6EyoypL1Gf9XAn_pfO6tKQ,11898
+graphharbor-0.13.0.post2.dist-info/METADATA,sha256=lOZJgRe0mGr1SuCCi1xkbXvtDkeRQRY1SvY-Qou86Ks,2503
+graphharbor-0.13.0.post2.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+graphharbor-0.13.0.post2.dist-info/entry_points.txt,sha256=hM5uFwJylE-2OVnqAus0QZSFkYsvtVCoUkE9Mb3us-c,49
+graphharbor-0.13.0.post2.dist-info/licenses/LICENSE,sha256=VOzjTuqsyEVtwd7ylP1eoLjPAAvdB6iC9a7JBGFJUgE,1080
+graphharbor-0.13.0.post2.dist-info/RECORD,,

graphharbor-0.13.0.post2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

graphharbor-0.13.0.post2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+graphharbor = langhost.cli:cli

graphharbor-0.13.0.post2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mohankumar Ramachandran
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

langhost/__init__.py

@@ -0,0 +1,10 @@
+"""GraphHarbor CLI for a self-hosted LangGraph Agent Server."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("graphharbor")
+except PackageNotFoundError:  # pragma: no cover
+    __version__ = "0.0.0"
+
+__all__ = ["__version__"]

langhost/__main__.py

@@ -0,0 +1,4 @@
+from langhost.cli import cli
+
+if __name__ == "__main__":
+    cli()

langhost/cli.py

@@ -0,0 +1,512 @@
+"""GraphHarbor CLI — config loading plus the self-owned Agent Server."""
+
+from __future__ import annotations
+
+import logging
+import os
+import pathlib
+import socket
+import sys
+from collections.abc import Sequence
+from typing import Any, cast
+
+import click
+from dotenv import load_dotenv
+from langgraph_cli.config import validate_config_file
+from langgraph_cli.constants import DEFAULT_CONFIG
+from pyfiglet import figlet_format
+
+from langgraph_runtime_pg.graph_registry import resolve_config_base_dir
+from langhost import __version__
+from langhost.server import run_server
+
+# Always the open Postgres+Redis runtime.
+RUNTIME_EDITION = "pg"
+DEFAULT_PORT = 31296
+LOG_LEVELS = ["CRITICAL", "ERROR", "WARNING", "INFO", "DEBUG"]
+DEFAULT_STUDIO_ORIGIN = "https://smith.langchain.com"
+
+# Upstream run_server always logs an inmem-oriented welcome; replace it for GraphHarbor.
+_UPSTREAM_WELCOME_MARKER = "This in-memory server is designed for development and testing"
+
+
+def _resolve_port(host: str, port: int | None) -> int:
+    """Return the requested port or the first free port, without private API imports."""
+    requested = port if port is not None else DEFAULT_PORT
+    with socket.socket(
+        socket.AF_INET6 if ":" in host else socket.AF_INET, socket.SOCK_STREAM
+    ) as sock:
+        try:
+            sock.bind((host, requested))
+        except OSError:
+            sock.bind((host, 0))
+            return int(sock.getsockname()[1])
+    return requested
+
+
+def _display_host(host: str) -> str:
+    if host in {"0.0.0.0", "::"}:
+        return "127.0.0.1"
+    if ":" in host and not host.startswith("["):
+        return f"[{host}]"
+    return host
+
+
+def _server_base_url(
+    host: str,
+    port: int,
+    *,
+    ssl: bool,
+    mount_prefix: str | None,
+) -> str:
+    scheme = "https" if ssl else "http"
+    url = f"{scheme}://{_display_host(host)}:{port}"
+    if mount_prefix:
+        url += mount_prefix
+    return url
+
+
+def _langhost_welcome(
+    *,
+    host: str,
+    port: int,
+    ssl: bool,
+    studio_origin: str | None,
+    mount_prefix: str | None,
+) -> str:
+    api_url = _server_base_url(host, port, ssl=ssl, mount_prefix=mount_prefix)
+    origin = (studio_origin or DEFAULT_STUDIO_ORIGIN).rstrip("/")
+    studio_url = f"{origin}/studio/?baseUrl={api_url}"
+    agent_chat_url = f"https://agentchat.vercel.app/?apiUrl={api_url}&assistantId=agent"
+    title = figlet_format("GraphHarbor", font="standard").rstrip()
+    repo_url = "https://github.com/ljxpython/graphharbor"
+    return f"""
+
+{title}
+
+- 🚀 API: \033[36m{api_url}\033[0m
+- 🎨 Studio UI: \033[36m{studio_url}\033[0m
+- 📚 API Docs: \033[36m{api_url}/docs\033[0m
+- 💬 Agent Chat UI: \033[36m{agent_chat_url}\033[0m
+
+\033[1;33m★\033[0m  If GraphHarbor helps you, a \033[1;33mGitHub star\033[0m keeps the project alive:
+   \033[36m{repo_url}\033[0m
+
+Self-hosted LangGraph Agent Server with PostgreSQL + Redis.
+GraphHarbor {__version__}
+
+"""
+
+
+class _ReplaceWelcomeBanner(logging.Filter):
+    """Swap the upstream inmem welcome for a prebuilt GraphHarbor banner."""
+
+    def __init__(self, welcome: str) -> None:
+        super().__init__()
+        self._welcome = welcome
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        if _UPSTREAM_WELCOME_MARKER in record.getMessage():
+            record.msg = self._welcome
+            record.args = ()
+        return (
+            True  # NOSONAR — logging.Filter keeps all records; we only rewrite the welcome banner
+        )
+
+
+def _validate_serve_options(
+    reload: bool,
+    workers: int,
+    ssl_certfile: pathlib.Path | None,
+    ssl_keyfile: pathlib.Path | None,
+    tunnel: bool,
+    wait_for_client: bool,
+    debug_port: int | None,
+) -> None:
+    """Validate mutually exclusive CLI options, raising UsageError on conflicts."""
+    if reload and workers > 1:
+        raise click.UsageError("Cannot combine --reload with --workers > 1.")
+    if (ssl_certfile is None) != (ssl_keyfile is None):
+        raise click.UsageError("Both --ssl-certfile and --ssl-keyfile are required for HTTPS.")
+    if ssl_certfile and ssl_keyfile and tunnel:
+        raise click.UsageError("Cannot combine --tunnel with SSL options.")
+    if wait_for_client and debug_port is None:
+        raise click.UsageError("--wait-for-client requires --debug-port.")
+
+
+def _prepare_serve_env(
+    env_file: pathlib.Path | None,
+    database_uri: str | None,
+    redis_uri: str | None,
+    n_jobs_per_worker: int | None,
+) -> tuple[str, str, int | None]:
+    """Load dotenv and resolve database/redis URIs. Returns (db_uri, redis_uri, n_jobs)."""
+    load_dotenv(env_file or ".env", override=False)
+    os.environ["LANGGRAPH_RUNTIME_EDITION"] = RUNTIME_EDITION
+
+    database_uri = database_uri or os.environ.get("DATABASE_URI")
+    redis_uri = redis_uri or os.environ.get("REDIS_URI")
+    if not database_uri:
+        raise click.UsageError(
+            "DATABASE_URI is required. Please set it in the environment or pass it to the command via --database-uri."
+        )
+    if not redis_uri:
+        raise click.UsageError(
+            "REDIS_URI is required. Please set it in the environment or pass it to the command via --redis-uri."
+        )
+    if n_jobs_per_worker is None:
+        raw = os.environ.get("N_JOBS_PER_WORKER")
+        if raw:
+            n_jobs_per_worker = int(raw)
+    return database_uri, redis_uri, n_jobs_per_worker
+
+
+def _build_uvicorn_kwargs(workers: int) -> dict[str, Any]:
+    """Build extra kwargs passed to uvicorn."""
+    uvicorn_kwargs: dict[str, Any] = {}
+    if workers > 1:
+        uvicorn_kwargs["workers"] = workers
+    return uvicorn_kwargs
+
+
+def _resolve_mount_prefix(config_json: dict[str, Any]) -> tuple[dict | None, str | None]:
+    """Extract http config and resolve mount prefix from config/env."""
+    http_cfg = config_json.get("http")
+    mount_prefix = None
+    if isinstance(http_cfg, dict):
+        mount_prefix = http_cfg.get("mount_prefix")
+    mount_prefix = (
+        os.environ.get("MOUNT_PREFIX") or os.environ.get("LANGGRAPH_MOUNT_PREFIX") or mount_prefix
+    )
+    return http_cfg, mount_prefix
+
+
+@click.group()
+@click.version_option(version=__version__, prog_name="graphharbor")
+def cli() -> None:
+    """Self-hosted LangGraph Agent Server on PostgreSQL + Redis."""
+
+
+@cli.command(
+    "serve",
+    help=(
+        "Run the Agent Server (LANGGRAPH_RUNTIME_EDITION=pg). "
+        "Use --reload for local development; --workers for production."
+    ),
+)
+@click.option(
+    "--host",
+    default="127.0.0.1",
+    show_default=True,
+    help=(
+        "Bind address. Prefer 127.0.0.1 for local work; use 0.0.0.0 only on "
+        "trusted networks / behind a reverse proxy."
+    ),
+)
+@click.option(
+    "--port",
+    "-p",
+    default=DEFAULT_PORT,
+    show_default=True,
+    type=int,
+    help="Port to bind the Agent Server to.",
+)
+@click.option(
+    "--config",
+    "-c",
+    default=DEFAULT_CONFIG,
+    show_default=True,
+    type=click.Path(exists=True, dir_okay=False, path_type=pathlib.Path),
+    help="Path to langgraph.json (graphs, deps, env, auth, http, …).",
+)
+@click.option(
+    "--env-file",
+    type=click.Path(exists=True, dir_okay=False, path_type=pathlib.Path),
+    default=None,
+    help="Optional dotenv file to load before starting (default: .env if present).",
+)
+@click.option(
+    "--database-uri",
+    default=None,
+    help="Postgres URI (overrides DATABASE_URI). Required unless set in the environment.",
+)
+@click.option(
+    "--redis-uri",
+    default=None,
+    help="Redis URI (overrides REDIS_URI). Required unless set in the environment.",
+)
+@click.option(
+    "--reload",
+    is_flag=True,
+    help="Auto-reload on code changes (dev). Incompatible with --workers > 1.",
+)
+@click.option(
+    "--reload-include",
+    "reload_includes",
+    multiple=True,
+    help="Glob(s) to watch when --reload is set (repeatable).",
+)
+@click.option(
+    "--reload-exclude",
+    "reload_excludes",
+    multiple=True,
+    help="Glob(s) to ignore when --reload is set (repeatable).",
+)
+@click.option(
+    "--workers",
+    default=1,
+    show_default=True,
+    type=click.IntRange(min=1),
+    help="Uvicorn worker processes (prod). Incompatible with --reload.",
+)
+@click.option(
+    "--n-jobs-per-worker",
+    default=None,
+    type=int,
+    help=(
+        "Max concurrent background jobs per server process "
+        "(sets N_JOBS_PER_WORKER; default inside run_server is 1)."
+    ),
+)
+@click.option(
+    "--browser/--no-browser",
+    default=False,
+    help="Open LangSmith Studio in the browser when the server is ready.",
+)
+@click.option(
+    "--studio-url",
+    default=None,
+    help="LangSmith Studio base URL (default: https://smith.langchain.com).",
+)
+@click.option(
+    "--tunnel",
+    is_flag=True,
+    help="Expose the server via a Cloudflare tunnel (remote Studio access).",
+)
+@click.option(
+    "--debug-port",
+    default=None,
+    type=int,
+    help="Listen for a remote debugger (debugpy) on this port.",
+)
+@click.option(
+    "--wait-for-client",
+    is_flag=True,
+    help="With --debug-port, block until a debugger attaches.",
+)
+@click.option(
+    "--allow-blocking",
+    is_flag=True,
+    help="Do not raise on synchronous/blocking I/O in graph code.",
+)
+@click.option(
+    "--server-log-level",
+    default="INFO",
+    show_default=True,
+    type=click.Choice(LOG_LEVELS, case_sensitive=False),
+    help="Log level for uvicorn / GraphHarbor Agent Server.",
+)
+@click.option(
+    "--ssl-certfile",
+    type=click.Path(exists=True, dir_okay=False, path_type=pathlib.Path),
+    default=None,
+    help="TLS certificate file (serve over HTTPS).",
+)
+@click.option(
+    "--ssl-keyfile",
+    type=click.Path(exists=True, dir_okay=False, path_type=pathlib.Path),
+    default=None,
+    help="TLS private key file (serve over HTTPS).",
+)
+def serve(
+    host: str,  # NOSONAR - Click command signature intentionally wide
+    port: int,  # NOSONAR - Click command signature intentionally wide
+    config: pathlib.Path,
+    env_file: pathlib.Path | None,
+    database_uri: str | None,
+    redis_uri: str | None,
+    reload: bool,
+    reload_includes: tuple[str, ...],
+    reload_excludes: tuple[str, ...],
+    workers: int,
+    n_jobs_per_worker: int | None,
+    browser: bool,
+    studio_url: str | None,
+    tunnel: bool,
+    debug_port: int | None,
+    wait_for_client: bool,
+    allow_blocking: bool,
+    server_log_level: str,
+    ssl_certfile: pathlib.Path | None,
+    ssl_keyfile: pathlib.Path | None,
+) -> None:
+    _validate_serve_options(
+        reload, workers, ssl_certfile, ssl_keyfile, tunnel, wait_for_client, debug_port
+    )
+
+    config_json = validate_config_file(config)
+    if config_json.get("node_version"):
+        raise click.UsageError(
+            "JS graphs are not supported by langhost. Remove the 'node_version' field from the config."
+        )
+
+    cwd = pathlib.Path.cwd()
+    config_base_dir = resolve_config_base_dir(config, cast(dict[str, Any], config_json))
+    config_env = config_json.get("env")
+    if env_file is None and isinstance(config_env, str):
+        load_dotenv(config_base_dir / config_env, override=False)
+    database_uri, redis_uri, n_jobs_per_worker = _prepare_serve_env(
+        env_file, database_uri, redis_uri, n_jobs_per_worker
+    )
+    for import_root in (cwd, config_base_dir):
+        if str(import_root) not in sys.path:
+            sys.path.append(str(import_root))
+    for dep in config_json.get("dependencies", []):
+        dep_path = cwd / dep
+        if dep_path.is_dir() and dep_path.exists():
+            sys.path.append(str(dep_path))
+
+    includes: Sequence[str] | None = list(reload_includes) or None
+    excludes: Sequence[str] | None = list(reload_excludes) or None
+    uvicorn_kwargs = _build_uvicorn_kwargs(workers)
+    http_cfg, mount_prefix = _resolve_mount_prefix(cast(dict[str, Any], config_json))
+
+    port = _resolve_port(host, port)
+    welcome = _langhost_welcome(
+        host=host,
+        port=port,
+        ssl=ssl_certfile is not None and ssl_keyfile is not None,
+        studio_origin=studio_url,
+        mount_prefix=mount_prefix,
+    )
+    api_cli_logger = logging.getLogger("graphharbor.cli")
+    banner_filter = _ReplaceWelcomeBanner(welcome)
+    api_cli_logger.addFilter(banner_filter)
+    try:
+        run_server(
+            host,
+            port,
+            reload,
+            config_json.get("graphs", {}),
+            n_jobs_per_worker=n_jobs_per_worker,
+            open_browser=browser,
+            tunnel=tunnel,
+            debug_port=debug_port,
+            wait_for_client=wait_for_client,
+            env=config_json.get("env"),
+            reload_includes=includes,
+            reload_excludes=excludes,
+            store=config_json.get("store"),
+            auth=config_json.get("auth"),
+            http=http_cfg,
+            ui=config_json.get("ui"),
+            ui_config=config_json.get("ui_config"),
+            webhooks=config_json.get("webhooks"),
+            checkpointer=config_json.get("checkpointer"),
+            studio_url=studio_url,
+            disable_persistence=config_json.get("disable_persistence", False),
+            allow_blocking=allow_blocking,
+            server_level=server_log_level,
+            ssl_certfile=ssl_certfile,
+            ssl_keyfile=ssl_keyfile,
+            runtime_edition=RUNTIME_EDITION,
+            __database_uri__=database_uri,
+            __redis_uri__=redis_uri,
+            __migrations_path__=None,
+            config=config_json,
+            base_dir=config_base_dir,
+            **uvicorn_kwargs,
+        )
+    finally:
+        api_cli_logger.removeFilter(banner_filter)
+
+
+@cli.command("migrate", help="Apply the explicit PostgreSQL schema migration job.")
+@click.argument(
+    "migration_action",
+    type=click.Choice(["upgrade", "current", "history", "stamp", "downgrade"]),
+    default="upgrade",
+)
+@click.argument("revision", required=False)
+def migrate_command(migration_action: str, revision: str | None) -> None:
+    """Run migrations separately from API startup."""
+    from langgraph_runtime_pg import migrate
+
+    if migration_action == "upgrade":
+        click.echo(f"upgraded to {migrate.upgrade_head()}")
+    elif migration_action == "stamp":
+        migrate.stamp_head()
+        click.echo("stamped head")
+    elif migration_action == "current":
+        migrate.current()
+    elif migration_action == "history":
+        migrate.history()
+    else:
+        migrate.downgrade(revision or "-1")
+        click.echo(f"downgraded to {revision or '-1'}")
+
+
+@cli.command("worker", help="Run the GraphHarbor worker against host PostgreSQL and Redis.")
+@click.option(
+    "--config",
+    "config_path",
+    default=DEFAULT_CONFIG,
+    show_default=True,
+    type=click.Path(exists=True, dir_okay=False, path_type=pathlib.Path),
+    help="Path to langgraph.json used for graph discovery.",
+)
+@click.option("--env-file", type=click.Path(exists=True, dir_okay=False, path_type=pathlib.Path))
+@click.option("--database-uri", default=None)
+@click.option("--redis-uri", default=None)
+@click.option("--n-jobs-per-worker", default=1, type=click.IntRange(min=1), show_default=True)
+@click.option(
+    "--compatibility-spike",
+    is_flag=True,
+    help="Use the legacy private worker only for comparison tests; never use in production.",
+)
+def worker_command(
+    config_path: pathlib.Path,
+    env_file: pathlib.Path | None,
+    database_uri: str | None,
+    redis_uri: str | None,
+    n_jobs_per_worker: int,
+    compatibility_spike: bool,
+) -> None:
+    """Start only the queue worker; migrations remain an explicit command."""
+    worker_config = validate_config_file(config_path)
+    worker_base_dir = resolve_config_base_dir(config_path, cast(dict[str, Any], worker_config))
+    worker_env = worker_config.get("env")
+    if env_file is None and isinstance(worker_env, str):
+        load_dotenv(worker_base_dir / worker_env, override=False)
+    database_uri, redis_uri, _ = _prepare_serve_env(
+        env_file, database_uri, redis_uri, n_jobs_per_worker
+    )
+    os.environ["DATABASE_URI"] = database_uri
+    os.environ["REDIS_URI"] = redis_uri
+    os.environ["GRAPHHARBOR_COMPATIBILITY_SPIKE"] = "1" if compatibility_spike else "0"
+
+    if compatibility_spike:
+        from langgraph_runtime_pg.production import lifespan
+        from langgraph_runtime_pg.queue import queue
+
+        async def _run_compatibility() -> None:
+            async with lifespan():
+                await queue()
+
+        import asyncio
+
+        asyncio.run(_run_compatibility())
+        return
+
+    async def _run() -> None:
+        from langgraph_runtime_pg.production_worker import run_worker
+
+        await run_worker(config_path)
+
+    import asyncio
+
+    asyncio.run(_run())
+
+
+if __name__ == "__main__":
+    cli()