langgraph-cli 0.1.6__py3-none-any.whl

langgraph_cli/cli.py

@@ -0,0 +1,301 @@
+import asyncio
+import json
+import os
+import pathlib
+import shutil
+import signal
+from datetime import datetime, timezone
+from typing import Coroutine, Optional
+
+import click
+
+import langgraph_cli.config
+import langgraph_cli.docker
+
+
+async def exec(cmd: str, *args: str, input: str = None, wait: float = None):
+    if wait:
+        await asyncio.sleep(wait)
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            cmd, *args, stdin=asyncio.subprocess.PIPE if input else None
+        )
+        await proc.communicate(input.encode() if input else None)
+        if (
+            proc.returncode != 0  # success
+            and proc.returncode != 130  # user interrupt
+        ):
+            raise click.exceptions.Exit(proc.returncode)
+    finally:
+        try:
+            if proc.returncode is None:
+                try:
+                    os.killpg(os.getpgid(proc.pid), signal.SIGINT)
+                except (ProcessLookupError, KeyboardInterrupt):
+                    pass
+        except UnboundLocalError:
+            pass
+
+
+PLACEHOLDER_NOW = object()
+
+
+async def exec_loop(cmd: str, *args: str, input: str = None):
+    now = datetime.now(timezone.utc).isoformat()
+    while True:
+        try:
+            await exec(
+                cmd, *(now if a is PLACEHOLDER_NOW else a for a in args), input=input
+            )
+            now = datetime.now(timezone.utc).isoformat()
+            await asyncio.sleep(1)
+        except Exception as e:
+            print(e)
+            pass
+
+
+async def gather(*coros: Coroutine):
+    tasks = [asyncio.create_task(coro) for coro in coros]
+    exceptions = []
+    while tasks:
+        done, tasks = await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
+        for t in tasks:
+            t.cancel()
+        for d in done:
+            if exc := d.exception():
+                exceptions.append(exc)
+
+
+OPT_O = click.option(
+    "--docker-compose",
+    "-d",
+    help="Advanced: Path to docker-compose.yml file with additional services to launch",
+    type=click.Path(
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        resolve_path=True,
+        path_type=pathlib.Path,
+    ),
+)
+OPT_C = click.option(
+    "--config",
+    "-c",
+    help="""Path to configuration file declaring dependencies, graphs and environment variables.
+    
+    \b
+    Example:
+    {
+        "dependencies": [
+            "langchain_openai",
+            "./your_package"
+        ],
+        "graphs": {
+            "my_graph_id": "./your_package/your_file.py:variable"
+        },
+        "env": "./.env"
+    }
+
+    Defaults to looking for langgraph.json in the current directory.""",
+    default="langgraph.json",
+    type=click.Path(
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        resolve_path=True,
+        path_type=pathlib.Path,
+    ),
+)
+OPT_PORT = click.option(
+    "--port", "-p", type=int, default=8123, show_default=True, help="Port to expose"
+)
+OPT_DEBUGGER_PORT = click.option(
+    "--debugger-port",
+    "-dp",
+    type=int,
+    default=8124,
+    show_default=True,
+    help="Port to expose debug UI on",
+)
+
+
+@click.group()
+def cli():
+    pass
+
+
+@click.option(
+    "--recreate/--no-recreate",
+    default=False,
+    show_default=True,
+    help="Clear previous data",
+)
+@click.option(
+    "--pull/--no-pull", default=True, show_default=True, help="Pull latest images"
+)
+@OPT_DEBUGGER_PORT
+@OPT_PORT
+@OPT_O
+@OPT_C
+@cli.command(help="Start langgraph API server")
+def up(
+    config: pathlib.Path,
+    docker_compose: Optional[pathlib.Path],
+    port: int,
+    recreate: bool,
+    pull: bool,
+    debugger_port: Optional[int],
+):
+    with asyncio.Runner() as runner:
+        # check docker available
+        try:
+            runner.run(exec("docker", "--version"))
+            runner.run(exec("docker", "compose", "version"))
+        except click.exceptions.Exit:
+            click.echo("Docker not installed or not running")
+            return
+        # pull latest images
+        if pull:
+            runner.run(exec("docker", "pull", "langchain/langserve"))
+        # prepare args
+        stdin = langgraph_cli.docker.compose(port=port, debugger_port=debugger_port)
+        args = [
+            "--project-directory",
+            config.parent,
+            "-f",
+            "-",  # stdin
+        ]
+        # apply options
+        if docker_compose:
+            args.extend(["-f", str(docker_compose)])
+        args.append("up")
+        if config:
+            with open(config) as f:
+                stdin += langgraph_cli.config.config_to_compose(config, json.load(f))
+        if recreate:
+            args.extend(["--force-recreate", "--remove-orphans"])
+            shutil.rmtree(".langserve-data", ignore_errors=True)
+        # run docker compose
+        runner.run(exec("docker", "compose", *args, input=stdin))
+
+
+@OPT_C
+@click.option("--tag", "-t", help="Tag for the image", required=True)
+@cli.command(help="Build langgraph API server image")
+def build(
+    config: pathlib.Path,
+    tag: str,
+):
+    with asyncio.Runner() as runner:
+        # check docker available
+        try:
+            runner.run(exec("docker", "--version"))
+            runner.run(exec("docker", "compose", "version"))
+        except click.exceptions.Exit:
+            click.echo("Docker not installed or not running")
+            return
+        # apply options
+        args = [
+            "-f",
+            "-",  # stdin
+            "-t",
+            tag,
+        ]
+        with open(config) as f:
+            stdin = langgraph_cli.config.config_to_docker(config, json.load(f))
+        # run docker build
+        runner.run(exec("docker", "build", *args, config.parent, input=stdin))
+
+
+@OPT_DEBUGGER_PORT
+@OPT_PORT
+@OPT_O
+@OPT_C
+@cli.command(help="Write k8s files", hidden=True)
+def k8s(
+    config: pathlib.Path,
+    docker_compose: Optional[pathlib.Path],
+    port: int,
+    debugger_port: Optional[int],
+):
+    with asyncio.Runner() as runner:
+        # check docker available
+        try:
+            runner.run(exec("docker", "--version"))
+            runner.run(exec("docker", "compose", "version"))
+        except click.exceptions.Exit:
+            click.echo("Docker not installed or not running")
+            return
+        # prepare args
+        stdin = langgraph_cli.docker.compose(port=port, debugger_port=debugger_port)
+        args = [
+            "-f",
+            "-",  # stdin
+        ]
+        # apply options
+        if docker_compose:
+            args.extend(["-f", str(docker_compose)])
+        args.append("convert")
+        if config:
+            with open(config) as f:
+                stdin += langgraph_cli.config.config_to_compose(config, json.load(f))
+        # run kompose convert
+        runner.run(exec("kompose", *args, input=stdin))
+
+
+@OPT_O
+@OPT_PORT
+@cli.command()
+def watch(override: pathlib.Path, port: int):
+    compose = langgraph_cli.docker.compose(port=port)
+
+    with asyncio.Runner() as runner:
+        try:
+            runner.run(
+                gather(
+                    exec(
+                        "docker",
+                        "compose",
+                        "--project-directory",
+                        override.parent,
+                        "-f",
+                        "-",
+                        "-f",
+                        str(override),
+                        "watch",
+                        input=compose,
+                    ),
+                    exec_loop(
+                        "docker",
+                        "compose",
+                        "--project-directory",
+                        override.parent,
+                        "-f",
+                        "-",
+                        "-f",
+                        str(override),
+                        "logs",
+                        "--follow",
+                        "--since",
+                        PLACEHOLDER_NOW,
+                        "langserve",
+                        input=compose,
+                    ),
+                )
+            )
+        finally:
+            # docker compose watch doesn't clean up on exit, so we need to do it
+            runner.run(
+                exec(
+                    "docker",
+                    "compose",
+                    "--project-directory",
+                    override.parent,
+                    "-f",
+                    "-",
+                    "-f",
+                    str(override),
+                    "kill",
+                    input=compose,
+                )
+            )

langgraph_cli/config.py

@@ -0,0 +1,120 @@
+import json
+import os
+import pathlib
+import textwrap
+from typing import TypedDict, Union
+
+
+class Config(TypedDict):
+    dependencies: list[str]
+    graphs: dict[str, str]
+    env: Union[dict[str, str], str]
+
+
+def config_to_docker(config_path: pathlib.Path, config: Config):
+    pypi_deps = [dep for dep in config["dependencies"] if not dep.startswith(".")]
+    local_pkgs: dict[pathlib.Path, str] = {}
+    faux_pkgs: dict[pathlib.Path, str] = {}
+    pkg_names = set()
+
+    for local_dep in config["dependencies"]:
+        if local_dep.startswith("."):
+            resolved = config_path.parent / local_dep
+
+            # validate local dependency
+            if not resolved.exists():
+                raise FileNotFoundError(f"Could not find local dependency: {resolved}")
+            elif not resolved.is_dir():
+                raise NotADirectoryError(
+                    f"Local dependency must be a directory: {resolved}"
+                )
+            elif resolved.name in pkg_names:
+                raise ValueError(f"Duplicate local dependency: {resolved}")
+            else:
+                pkg_names.add(resolved.name)
+
+            # if it's installable, add it to local_pkgs
+            # otherwise, add it to faux_pkgs, and create a pyproject.toml
+            files = os.listdir(resolved)
+            if "pyproject.toml" in files:
+                local_pkgs[resolved] = local_dep
+            elif "setup.py" in files:
+                local_pkgs[resolved] = local_dep
+            else:
+                faux_pkgs[resolved] = local_dep
+
+    for graph_id, import_str in config["graphs"].items():
+        module_str, _, attr_str = import_str.partition(":")
+        if not module_str or not attr_str:
+            message = (
+                'Import string "{import_str}" must be in format "<module>:<attribute>".'
+            )
+            raise ValueError(message.format(import_str=import_str))
+        if module_str.startswith("."):
+            resolved = config_path.parent / module_str
+            if not resolved.exists():
+                raise FileNotFoundError(f"Could not find local module: {resolved}")
+            elif not resolved.is_file():
+                raise IsADirectoryError(f"Local module must be a file: {resolved}")
+            else:
+                for local_pkg in local_pkgs:
+                    if resolved.is_relative_to(local_pkg):
+                        resolved = resolved.relative_to(local_pkg)
+                        break
+                else:
+                    for faux_pkg in faux_pkgs:
+                        if resolved.is_relative_to(faux_pkg):
+                            resolved = resolved.relative_to(faux_pkg.parent)
+                            break
+                    else:
+                        raise ValueError(
+                            f"Module '{import_str}' not found in 'dependencies' list"
+                            "Add its containing package to 'dependencies' list."
+                        )
+            # rewrite module_str to be a python import path
+            module_str = f"{'.'.join(resolved.parts[:-1])}"
+            if resolved.stem == "__init__":
+                pass
+            else:
+                module_str = f"{module_str}.{resolved.stem}"
+            # update the config
+            config["graphs"][graph_id] = f"{module_str}:{attr_str}"
+
+    faux_pkgs_str = "\n\n".join(
+        f"ADD {relpath} /tmp/{fullpath.name}/{fullpath.name}\n                RUN touch /tmp/{fullpath.name}/pyproject.toml"
+        for fullpath, relpath in faux_pkgs.items()
+    )
+    local_pkgs_str = "\n".join(
+        f"ADD {relpath} /tmp/{fullpath.name}"
+        for fullpath, relpath in local_pkgs.items()
+    )
+
+    return f"""FROM langchain/langgraph-api
+
+ENV LANGSERVE_GRAPHS='{json.dumps(config["graphs"])}'
+
+{local_pkgs_str}
+
+{faux_pkgs_str}
+
+RUN pip install {' '.join(pypi_deps)} /tmp/*"""
+
+
+def config_to_compose(config_path: pathlib.Path, config: Config):
+    env_vars_str = (
+        "\n".join(f"            {k}: {v}" for k, v in config["env"].items())
+        if isinstance(config["env"], dict)
+        else ""
+    )
+    env_file_str = (
+        f"env_file: {config['env']}" if isinstance(config["env"], str) else ""
+    )
+
+    return f"""
+            {env_vars_str}
+        {env_file_str}
+        pull_policy: build
+        build:
+            dockerfile_inline: |
+{textwrap.indent(config_to_docker(config_path, config), "                ")}
+"""

langgraph_cli/docker.py

@@ -0,0 +1,70 @@
+import pathlib
+from typing import Optional
+
+
+ROOT = pathlib.Path(__file__).parent.resolve()
+
+
+DB = f"""
+    langgraph-postgres:
+        image: postgres:16
+        restart: on-failure
+        healthcheck:
+            test: pg_isready -U postgres
+            start_interval: 1s
+            start_period: 5s
+            interval: 5s
+            retries: 5
+        ports:
+            - "5433:5432"
+        environment:
+            POSTGRES_DB: postgres
+            POSTGRES_USER: postgres
+            POSTGRES_PASSWORD: postgres
+        volumes:
+            - ./.langgraph-data:/var/lib/postgresql/data
+            - {ROOT}/initdb:/docker-entrypoint-initdb.d
+"""
+
+DEBUGGER = """
+    langgraph-debugger:
+        image: langchain/langserve-debugger
+        restart: on-failure
+        ports:
+            - "{debugger_port}:5173"
+        depends_on:
+            langgraph-api:
+                condition: service_healthy
+        environment:
+            VITE_API_BASE_URL: http://localhost:{port}
+"""
+
+
+def compose(
+    *,
+    # postgres://user:password@host:port/database?option=value
+    postgres_uri: Optional[str] = None,
+    port: int,
+    debugger_port: Optional[int] = None,
+) -> str:
+    if postgres_uri is None:
+        include_db = True
+        postgres_uri = "postgres://postgres:postgres@langgraph-postgres:5432/postgres?sslmode=disable&search_path=langgraph"
+    else:
+        include_db = False
+
+    return f"""
+services:
+{DB if include_db else ""}
+{DEBUGGER.format(port=port, debugger_port=debugger_port) if debugger_port else ""}
+    langgraph-api:
+        image: langchain/langgraph-api
+        restart: on-failure
+        ports:
+            - "{port}:8000"
+        depends_on:
+            langgraph-postgres:
+                condition: service_healthy
+        environment:
+            POSTGRES_URI: {postgres_uri}
+"""

langgraph_cli/initdb/init.sql

@@ -0,0 +1 @@
+create schema if not exists langgraph;

langgraph_cli-0.1.6.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.1
+Name: langgraph-cli
+Version: 0.1.6
+Summary: 
+Author: Nuno Campos
+Author-email: nuno@langchain.dev
+Requires-Python: >=3.9.0,<3.12
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: click (>=8.1.7,<9.0.0)
+Description-Content-Type: text/markdown
+
+# langserve
+

langgraph_cli-0.1.6.dist-info/RECORD

@@ -0,0 +1,9 @@
+langgraph_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langgraph_cli/cli.py,sha256=v-A0IM2da2qH4B0pkT70z0vGkGIe9qc0-SIfPhOtsAE,8471
+langgraph_cli/config.py,sha256=iqyEHyDLP9N6EKIZmJqTRnu0-Mb01M1eDGBqWq6hVgs,4425
+langgraph_cli/docker.py,sha256=aTDT6G5jBZvAErRCdi37e5i6_8BURclPeN7DsmTpd7s,1828
+langgraph_cli/initdb/init.sql,sha256=ncuhSZOin6Kqw3XenItA33zKsf-U3RkGGwh56mx9hAM,39
+langgraph_cli-0.1.6.dist-info/METADATA,sha256=UrRZZzjPihQSmuaOF0KKf_gjzu-1d22vrZZQOp155AY,443
+langgraph_cli-0.1.6.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+langgraph_cli-0.1.6.dist-info/entry_points.txt,sha256=pq7AcWiYJM1-9PtAAF5jZKrOJw6WxnmYuVR_h6i1j4g,51
+langgraph_cli-0.1.6.dist-info/RECORD,,

langgraph_cli-0.1.6.dist-info/WHEEL

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

langgraph_cli-0.1.6.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+langgraph=langgraph_cli.cli:cli
+