langgraph-api 0.0.1__py3-none-any.whl

langgraph_api/auth/middleware.py

@@ -0,0 +1,41 @@
+from starlette.middleware import Middleware
+from starlette.middleware.authentication import (
+    AuthenticationError,
+    AuthenticationMiddleware,
+)
+from starlette.requests import HTTPConnection
+from starlette.responses import JSONResponse
+from starlette.types import Receive, Scope, Send
+
+from langgraph_api.config import LANGGRAPH_AUTH_TYPE
+
+
+def get_auth_backend():
+    if LANGGRAPH_AUTH_TYPE == "langsmith":
+        from langgraph_api.auth.langsmith.backend import LangsmithAuthBackend
+
+        return LangsmithAuthBackend()
+    else:
+        from langgraph_api.auth.noop import NoopAuthBackend
+
+        return NoopAuthBackend()
+
+
+def on_error(conn: HTTPConnection, exc: AuthenticationError):
+    return JSONResponse({"detail": str(exc)}, status_code=403)
+
+
+class ConditionalAuthenticationMiddleware(AuthenticationMiddleware):
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["root_path"] == "/noauth":
+            # disable auth for requests originating from SDK ASGI transport
+            # root_path cannot be set from a request, so safe to use as auth bypass
+            await self.app(scope, receive, send)
+            return
+
+        return await super().__call__(scope, receive, send)
+
+
+auth_middleware = Middleware(
+    ConditionalAuthenticationMiddleware, backend=get_auth_backend(), on_error=on_error
+)

langgraph_api/auth/noop.py

@@ -0,0 +1,14 @@
+from starlette.authentication import (
+    AuthCredentials,
+    AuthenticationBackend,
+    BaseUser,
+    UnauthenticatedUser,
+)
+from starlette.requests import HTTPConnection
+
+
+class NoopAuthBackend(AuthenticationBackend):
+    async def authenticate(
+        self, conn: HTTPConnection
+    ) -> tuple[AuthCredentials, BaseUser] | None:
+        return AuthCredentials(), UnauthenticatedUser()

langgraph_api/cli.py

@@ -0,0 +1,209 @@
+import contextlib
+import json
+import logging
+import os
+import pathlib
+import threading
+from collections.abc import Mapping
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+@contextlib.contextmanager
+def patch_environment(**kwargs):
+    """Temporarily patch environment variables.
+
+    Args:
+        **kwargs: Key-value pairs of environment variables to set.
+
+    Yields:
+        None
+    """
+    original = {}
+    try:
+        for key, value in kwargs.items():
+            if value is None:
+                original[key] = os.environ.pop(key, None)
+                continue
+            original[key] = os.environ.get(key)
+            os.environ[key] = value
+        yield
+    finally:
+        for key, value in original.items():
+            if value is None:
+                os.environ.pop(key, None)
+            else:
+                os.environ[key] = value
+
+
+def run_server(
+    host: str = "127.0.0.1",
+    port: int = 2024,
+    reload: bool = False,
+    graphs: dict | None = None,
+    n_jobs_per_worker: int | None = None,
+    env_file: str | None = None,
+    open_browser: bool = False,
+    debug_port: int | None = None,
+    env: str | pathlib.Path | Mapping[str, str] | None = None,
+):
+    """Run the LangGraph API server."""
+    import uvicorn
+
+    env_vars = env if isinstance(env, Mapping) else None
+    if isinstance(env, str | pathlib.Path):
+        try:
+            from dotenv.main import DotEnv
+
+            env_vars = DotEnv(dotenv_path=env).dict() or {}
+            logger.debug(f"Loaded environment variables from {env}: {sorted(env_vars)}")
+
+        except ImportError:
+            logger.warning(
+                "python_dotenv is not installed. Environment variables will not be available."
+            )
+
+    if debug_port is not None:
+        try:
+            import debugpy
+        except ImportError:
+            logger.warning("debugpy is not installed. Debugging will not be available.")
+            logger.info("To enable debugging, install debugpy: pip install debugpy")
+            return
+        debugpy.listen((host, debug_port))
+        logger.info(
+            f"🐛 Debugger listening on port {debug_port}. Waiting for client to attach..."
+        )
+        logger.info("To attach the debugger:")
+        logger.info("1. Open your python debugger client (e.g., Visual Studio Code).")
+        logger.info(
+            "2. Use the 'Remote Attach' configuration with the following settings:"
+        )
+        logger.info("   - Host: 0.0.0.0")
+        logger.info(f"   - Port: {debug_port}")
+        logger.info("3. Start the debugger to connect to the server.")
+        debugpy.wait_for_client()
+        logger.info("Debugger attached. Starting server...")
+
+    local_url = f"http://{host}:{port}"
+    studio_url = f"https://smith.langchain.com/studio/?baseUrl={local_url}"
+
+    def _open_browser():
+        import time
+        import urllib.request
+        import webbrowser
+
+        while True:
+            try:
+                with urllib.request.urlopen(f"{local_url}/ok") as response:
+                    if response.status == 200:
+                        webbrowser.open(studio_url)
+                        return
+            except urllib.error.URLError:
+                pass
+            time.sleep(0.1)
+
+    welcome = f"""
+
+        Welcome to
+
+╦  ┌─┐┌┐┌┌─┐╔═╗┬─┐┌─┐┌─┐┬ ┬
+║  ├─┤││││ ┬║ ╦├┬┘├─┤├─┘├─┤
+╩═╝┴ ┴┘└┘└─┘╚═╝┴└─┴ ┴┴  ┴ ┴
+
+- 🚀 API: \033[36m{local_url}\033[0m
+- 🎨 Studio UI: \033[36m{studio_url}\033[0m
+- 📚 API Docs: \033[36m{local_url}/docs\033[0m
+
+This in-memory server is designed for development and testing.
+For production use, please use LangGraph Cloud.
+
+"""
+    logger.info(welcome)
+    with patch_environment(
+        MIGRATIONS_PATH="__inmem",
+        DATABASE_URI=":memory:",
+        REDIS_URI="fake",
+        N_JOBS_PER_WORKER=str(n_jobs_per_worker if n_jobs_per_worker else 1),
+        LANGSERVE_GRAPHS=json.dumps(graphs) if graphs else None,
+        LANGSMITH_LANGGRAPH_API_VARIANT="test",
+        **(env_vars or {}),
+    ):
+        if open_browser:
+            threading.Thread(target=_open_browser, daemon=True).start()
+
+        uvicorn.run(
+            "langgraph_api.server:app",
+            host=host,
+            port=port,
+            reload=reload,
+            env_file=env_file,
+            access_log=False,
+            log_config={
+                "version": 1,
+                "incremental": False,
+                "disable_existing_loggers": False,
+                "formatters": {
+                    "simple": {"class": "langgraph_api.logging.Formatter"}
+                },
+                "handlers": {
+                    "console": {
+                        "class": "logging.StreamHandler",
+                        "formatter": "simple",
+                        "stream": "ext://sys.stdout",
+                    }
+                },
+                "root": {"handlers": ["console"]},
+            },
+        )
+
+
+def main():
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="CLI entrypoint for running the LangGraph API server."
+    )
+    parser.add_argument(
+        "--host", default="127.0.0.1", help="Host to bind the server to"
+    )
+    parser.add_argument(
+        "--port", type=int, default=2024, help="Port to bind the server to"
+    )
+    parser.add_argument("--no-reload", action="store_true", help="Disable auto-reload")
+    parser.add_argument(
+        "--config", default="langgraph.json", help="Path to configuration file"
+    )
+    parser.add_argument(
+        "--n-jobs-per-worker",
+        type=int,
+        help="Number of jobs per worker. Default is None (meaning 10)",
+    )
+    parser.add_argument(
+        "--no-browser", action="store_true", help="Disable automatic browser opening"
+    )
+    parser.add_argument(
+        "--debug-port", type=int, help="Port for debugger to listen on (default: none)"
+    )
+
+    args = parser.parse_args()
+
+    with open(args.config, encoding="utf-8") as f:
+        config_data = json.load(f)
+
+    graphs = config_data.get("graphs", {})
+    run_server(
+        args.host,
+        args.port,
+        not args.no_reload,
+        graphs,
+        n_jobs_per_worker=args.n_jobs_per_worker,
+        open_browser=not args.no_browser,
+        debug_port=args.debug_port,
+        env=config_data.get("env", None),
+    )
+
+
+if __name__ == "__main__":
+    main()

langgraph_api/config.py

@@ -0,0 +1,70 @@
+from os import environ, getenv
+
+from starlette.config import Config, undefined
+from starlette.datastructures import CommaSeparatedStrings
+
+env = Config()
+
+STATS_INTERVAL_SECS = env("STATS_INTERVAL_SECS", cast=int, default=60)
+HTTP_CONCURRENCY = env("HTTP_CONCURRENCY", cast=int, default=10)
+
+# storage
+
+DATABASE_URI = env("DATABASE_URI", cast=str, default=getenv("POSTGRES_URI", undefined))
+MIGRATIONS_PATH = env("MIGRATIONS_PATH", cast=str, default="/storage/migrations")
+
+# redis
+REDIS_URI = env("REDIS_URI", cast=str)
+REDIS_MAX_CONNECTIONS = env("REDIS_MAX_CONNECTIONS", cast=int, default=500)
+
+# server
+
+CORS_ALLOW_ORIGINS = env("CORS_ALLOW_ORIGINS", cast=CommaSeparatedStrings, default="*")
+
+# queue
+
+BG_JOB_NO_DELAY = env("BG_JOB_NO_DELAY", cast=bool, default=False)
+N_JOBS_PER_WORKER = env("N_JOBS_PER_WORKER", cast=int, default=10)
+BG_JOB_TIMEOUT_SECS = env("BG_JOB_TIMEOUT_SECS", cast=float, default=3600)
+FF_CRONS_ENABLED = env("FF_CRONS_ENABLED", cast=bool, default=True)
+
+# auth
+
+LANGGRAPH_AUTH_TYPE = env("LANGGRAPH_AUTH_TYPE", cast=str, default="noop")
+
+if LANGGRAPH_AUTH_TYPE == "langsmith":
+    LANGSMITH_AUTH_ENDPOINT = env("LANGSMITH_AUTH_ENDPOINT", cast=str)
+    LANGSMITH_TENANT_ID = env("LANGSMITH_TENANT_ID", cast=str)
+    LANGSMITH_AUTH_VERIFY_TENANT_ID = env(
+        "LANGSMITH_AUTH_VERIFY_TENANT_ID", cast=bool, default=True
+    )
+else:
+    LANGSMITH_AUTH_ENDPOINT = env(
+        "LANGSMITH_AUTH_ENDPOINT",
+        cast=str,
+        default=getenv(
+            "LANGCHAIN_ENDPOINT",
+            getenv("LANGSMITH_ENDPOINT", "https://api.smith.langchain.com"),
+        ),
+    )
+
+# license
+
+LANGGRAPH_CLOUD_LICENSE_KEY = env("LANGGRAPH_CLOUD_LICENSE_KEY", cast=str, default="")
+LANGSMITH_API_KEY = env(
+    "LANGSMITH_API_KEY", cast=str, default=getenv("LANGCHAIN_API_KEY", "")
+)
+
+# if langsmith api key is set, enable tracing unless explicitly disabled
+
+if (
+    LANGSMITH_API_KEY
+    and not getenv("LANGCHAIN_TRACING_V2")
+    and not getenv("LANGCHAIN_TRACING")
+):
+    environ["LANGCHAIN_TRACING_V2"] = "true"
+
+# if variant is "licensed", update to "local" if using LANGSMITH_API_KEY instead
+
+if getenv("LANGSMITH_LANGGRAPH_API_VARIANT") == "licensed" and LANGSMITH_API_KEY:
+    environ["LANGSMITH_LANGGRAPH_API_VARIANT"] = "local"

langgraph_api/cron_scheduler.py

@@ -0,0 +1,60 @@
+import asyncio
+from random import random
+
+import structlog
+from langchain_core.runnables.config import run_in_executor
+
+from langgraph_api.models.run import create_valid_run
+from langgraph_api.utils import next_cron_date
+from langgraph_storage.database import connect
+from langgraph_storage.ops import Crons
+from langgraph_storage.retry import retry_db
+
+logger = structlog.stdlib.get_logger(__name__)
+
+SLEEP_TIME = 5
+
+
+@retry_db
+async def cron_scheduler():
+    logger.info("Starting cron scheduler")
+    while True:
+        try:
+            async with connect() as conn:
+                async for cron in Crons.next(conn):
+                    logger.debug(f"Scheduling cron run {cron}")
+                    try:
+                        run_payload = cron["payload"]
+                        run = await create_valid_run(
+                            conn,
+                            thread_id=str(cron.get("thread_id"))
+                            if cron.get("thread_id")
+                            else None,
+                            payload=run_payload,
+                            user_id=cron.get("user_id"),
+                            headers={},
+                        )
+                        if not run:
+                            logger.error(
+                                "Run not created for cron_id={} payload".format(
+                                    cron["cron_id"],
+                                )
+                            )
+                    except Exception as e:
+                        logger.error(
+                            "Error scheduling cron run cron_id={}".format(
+                                cron["cron_id"]
+                            ),
+                            exc_info=e,
+                        )
+                    next_run_date = await run_in_executor(
+                        None, next_cron_date, cron["schedule"], cron["now"]
+                    )
+                    await Crons.set_next_run_date(conn, cron["cron_id"], next_run_date)
+
+            await asyncio.sleep(SLEEP_TIME)
+        except asyncio.CancelledError:
+            raise
+        except Exception as e:
+            logger.error("Error in cron_scheduler", exc_info=e)
+            await asyncio.sleep(SLEEP_TIME + random())

langgraph_api/errors.py

@@ -0,0 +1,52 @@
+import jsonschema_rs
+import structlog
+from starlette.exceptions import HTTPException
+from starlette.requests import Request
+from starlette.responses import JSONResponse, Response
+
+logger = structlog.stdlib.get_logger(__name__)
+
+
+def is_body_allowed_for_status_code(status_code: int | None) -> bool:
+    if status_code is None:
+        return True
+    return not (status_code < 200 or status_code in {204, 205, 304})
+
+
+async def http_exception_handler(request: Request, exc: HTTPException) -> Response:
+    headers = getattr(exc, "headers", None)
+    if not is_body_allowed_for_status_code(exc.status_code):
+        return Response(status_code=exc.status_code, headers=headers)
+    return JSONResponse(
+        {"detail": exc.detail}, status_code=exc.status_code, headers=headers
+    )
+
+
+async def validation_error_handler(request, exc: jsonschema_rs.ValidationError):
+    return await http_exception_handler(
+        request, HTTPException(status_code=422, detail=str(exc))
+    )
+
+
+async def value_error_handler(request, exc: ValueError):
+    logger.exception("Bad Request Error", exc_info=exc)
+    return await http_exception_handler(
+        request, HTTPException(status_code=400, detail=str(exc))
+    )
+
+
+async def overloaded_error_handler(request, exc: ValueError):
+    logger.exception("Overloaded Error", exc_info=exc)
+    return await http_exception_handler(
+        request, HTTPException(status_code=503, detail=str(exc))
+    )
+
+
+class UserInterrupt(Exception):
+    def __init__(self, message="User interrupted the run"):
+        super().__init__(message)
+
+
+class UserRollback(UserInterrupt):
+    def __init__(self):
+        super().__init__("User requested rollback of the run")