langgraph-api 0.0.1__py3-none-any.whl

LICENSE

@@ -0,0 +1,93 @@
+Elastic License 2.0
+
+URL: https://www.elastic.co/licensing/elastic-license
+
+## Acceptance
+
+By using the software, you agree to all of the terms and conditions below.
+
+## Copyright License
+
+The licensor grants you a non-exclusive, royalty-free, worldwide,
+non-sublicensable, non-transferable license to use, copy, distribute, make
+available, and prepare derivative works of the software, in each case subject to
+the limitations and conditions below.
+
+## Limitations
+
+You may not provide the software to third parties as a hosted or managed
+service, where the service provides users with access to any substantial set of
+the features or functionality of the software.
+
+You may not move, change, disable, or circumvent the license key functionality
+in the software, and you may not remove or obscure any functionality in the
+software that is protected by the license key.
+
+You may not alter, remove, or obscure any licensing, copyright, or other notices
+of the licensor in the software. Any use of the licensor’s trademarks is subject
+to applicable law.
+
+## Patents
+
+The licensor grants you a license, under any patent claims the licensor can
+license, or becomes able to license, to make, have made, use, sell, offer for
+sale, import and have imported the software, in each case subject to the
+limitations and conditions in this license. This license does not cover any
+patent claims that you cause to be infringed by modifications or additions to
+the software. If you or your company make any written claim that the software
+infringes or contributes to infringement of any patent, your patent license for
+the software granted under these terms ends immediately. If your company makes
+such a claim, your patent license ends immediately for work on behalf of your
+company.
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of the software from you
+also gets a copy of these terms.
+
+If you modify the software, you must include in any modified copies of the
+software prominent notices stating that you have modified the software.
+
+## No Other Rights
+
+These terms do not imply any licenses other than those expressly granted in
+these terms.
+
+## Termination
+
+If you use the software in violation of these terms, such use is not licensed,
+and your licenses will automatically terminate. If the licensor provides you
+with a notice of your violation, and you cease all violation of this license no
+later than 30 days after you receive that notice, your licenses will be
+reinstated retroactively. However, if you violate these terms after such
+reinstatement, any additional violation of these terms will cause your licenses
+to terminate automatically and permanently.
+
+## No Liability
+
+*As far as the law allows, the software comes as is, without any warranty or
+condition, and the licensor will not be liable to you for any damages arising
+out of these terms or the use or nature of the software, under any kind of
+legal claim.*
+
+## Definitions
+
+The **licensor** is the entity offering these terms, and the **software** is the
+software the licensor makes available under these terms, including any portion
+of it.
+
+**you** refers to the individual or entity agreeing to these terms.
+
+**your company** is any legal entity, sole proprietorship, or other kind of
+organization that you work for, plus all organizations that have control over,
+are under the control of, or are under common control with that
+organization. **control** means ownership of substantially all the assets of an
+entity, or the power to direct its management and policies by vote, contract, or
+otherwise. Control can be direct or indirect.
+
+**your licenses** are all the licenses granted to you for the software under
+these terms.
+
+**use** means anything you do with the software requiring one of your licenses.
+
+**trademark** means trademarks, service marks, and similar rights.

langgraph_api/api/__init__.py

@@ -0,0 +1,63 @@
+import asyncio
+
+from starlette.requests import Request
+from starlette.responses import HTMLResponse, JSONResponse, Response
+from starlette.routing import BaseRoute, Mount, Route
+
+from langgraph_api.api.assistants import assistants_routes
+from langgraph_api.api.meta import meta_info, meta_metrics
+from langgraph_api.api.openapi import get_openapi_spec
+from langgraph_api.api.runs import runs_routes
+from langgraph_api.api.store import store_routes
+from langgraph_api.api.threads import threads_routes
+from langgraph_api.auth.middleware import auth_middleware
+from langgraph_api.config import MIGRATIONS_PATH
+from langgraph_api.graph import js_bg_tasks
+from langgraph_api.js.remote import js_healthcheck
+from langgraph_api.validation import DOCS_HTML
+from langgraph_storage.database import connect, healthcheck
+
+
+async def ok(request: Request):
+    check_db = int(request.query_params.get("check_db", "0"))  # must be "0" or "1"
+    if check_db:
+        await healthcheck()
+    if js_bg_tasks:
+        await js_healthcheck()
+    return JSONResponse({"ok": True})
+
+
+async def openapi(request: Request):
+    spec = await asyncio.to_thread(get_openapi_spec)
+    return Response(spec, media_type="application/json")
+
+
+async def docs(request: Request):
+    return HTMLResponse(DOCS_HTML)
+
+
+routes: list[BaseRoute] = [
+    Route("/ok", ok, methods=["GET"]),
+    Route("/openapi.json", openapi, methods=["GET"]),
+    Route("/docs", docs, methods=["GET"]),
+    Route("/info", meta_info, methods=["GET"]),
+    Route("/metrics", meta_metrics, methods=["GET"]),
+    Mount(
+        "",
+        middleware=[auth_middleware],
+        routes=[*assistants_routes, *runs_routes, *threads_routes, *store_routes],
+    ),
+]
+
+
+if "inmem" in MIGRATIONS_PATH:
+
+    async def truncate(request: Request):
+        from langgraph_storage.checkpoint import Checkpointer
+
+        Checkpointer().clear()
+        async with connect() as conn:
+            conn.clear()
+        return JSONResponse({"ok": True})
+
+    routes.insert(0, Route("/internal/truncate", truncate, methods=["POST"]))

langgraph_api/api/assistants.py

@@ -0,0 +1,326 @@
+from typing import Any
+from uuid import uuid4
+
+from langchain_core.runnables.utils import create_model
+from langgraph.pregel import Pregel
+from starlette.exceptions import HTTPException
+from starlette.responses import Response
+from starlette.routing import BaseRoute
+
+from langgraph_api.graph import get_assistant_id, get_graph
+from langgraph_api.js.remote import RemotePregel
+from langgraph_api.route import ApiRequest, ApiResponse, ApiRoute
+from langgraph_api.serde import ajson_loads
+from langgraph_api.utils import fetchone, validate_uuid
+from langgraph_api.validation import (
+    AssistantCreate,
+    AssistantPatch,
+    AssistantSearchRequest,
+    AssistantVersionChange,
+    AssistantVersionsSearchRequest,
+)
+from langgraph_storage.database import connect
+from langgraph_storage.ops import Assistants
+from langgraph_storage.retry import retry_db
+
+
+def _state_jsonschema(graph: Pregel) -> dict | None:
+    fields: dict = {}
+    for k in graph.stream_channels_list:
+        v = graph.channels[k]
+        try:
+            create_model(k, __root__=(v.UpdateType, None)).schema()
+            fields[k] = (v.UpdateType, None)
+        except Exception:
+            fields[k] = (Any, None)
+    return create_model(graph.get_name("State"), **fields).schema()
+
+
+def _graph_schemas(graph: Pregel) -> dict:
+    try:
+        input_schema = graph.get_input_jsonschema()
+    except Exception:
+        input_schema = None
+    try:
+        output_schema = graph.get_output_jsonschema()
+    except Exception:
+        output_schema = None
+    state_schema = _state_jsonschema(graph)
+    try:
+        config_schema = (
+            graph.config_schema().__fields__["configurable"].annotation.schema()
+            if "configurable" in graph.config_schema().__fields__
+            else {}
+        )
+    except Exception:
+        config_schema = None
+    return {
+        "input_schema": input_schema,
+        "output_schema": output_schema,
+        "state_schema": state_schema,
+        "config_schema": config_schema,
+    }
+
+
+@retry_db
+async def create_assistant(request: ApiRequest) -> ApiResponse:
+    payload = await request.json(AssistantCreate)
+    """Create an assistant."""
+    if assistant_id := payload.get("assistant_id"):
+        validate_uuid(assistant_id, "Invalid assistant ID: must be a UUID")
+    async with connect() as conn:
+        assistant = await Assistants.put(
+            conn,
+            assistant_id or str(uuid4()),
+            config=payload.get("config") or {},
+            graph_id=payload["graph_id"],
+            metadata=payload.get("metadata") or {},
+            if_exists=payload.get("if_exists") or "raise",
+            name=payload.get("name") or "Untitled",
+        )
+    return ApiResponse(await fetchone(assistant, not_found_code=409))
+
+
+@retry_db
+async def search_assistants(
+    request: ApiRequest,
+) -> ApiResponse:
+    """List assistants."""
+    payload = await request.json(AssistantSearchRequest)
+    async with connect() as conn:
+        assistants_iter = await Assistants.search(
+            conn,
+            graph_id=payload.get("graph_id"),
+            metadata=payload.get("metadata"),
+            limit=payload.get("limit") or 10,
+            offset=payload.get("offset") or 0,
+        )
+    return ApiResponse([assistant async for assistant in assistants_iter])
+
+
+@retry_db
+async def get_assistant(
+    request: ApiRequest,
+) -> ApiResponse:
+    assistant_id = request.path_params["assistant_id"]
+    """Get an assistant by ID."""
+    validate_uuid(assistant_id, "Invalid assistant ID: must be a UUID")
+    async with connect() as conn:
+        assistant = await Assistants.get(conn, assistant_id)
+    return ApiResponse(await fetchone(assistant))
+
+
+@retry_db
+async def get_assistant_graph(
+    request: ApiRequest,
+) -> ApiResponse:
+    """Get an assistant by ID."""
+    assistant_id = get_assistant_id(str(request.path_params["assistant_id"]))
+    validate_uuid(assistant_id, "Invalid assistant ID: must be a UUID")
+    async with connect() as conn:
+        assistant_ = await Assistants.get(conn, assistant_id)
+    assistant = await fetchone(assistant_)
+    config = await ajson_loads(assistant["config"])
+    graph = get_graph(assistant["graph_id"], config)
+
+    xray: bool | int = False
+    xray_query = request.query_params.get("xray")
+    if xray_query:
+        if xray_query in ("true", "True"):
+            xray = True
+        elif xray_query in ("false", "False"):
+            xray = False
+        else:
+            try:
+                xray = int(xray_query)
+            except ValueError:
+                raise HTTPException(422, detail="Invalid xray value") from None
+
+            if xray <= 0:
+                raise HTTPException(422, detail="Invalid xray value") from None
+
+    if isinstance(graph, RemotePregel):
+        drawable_graph = await graph.fetch_graph(xray=xray)
+        return ApiResponse(drawable_graph.to_json())
+    return ApiResponse(graph.get_graph(xray=xray).to_json())
+
+
+@retry_db
+async def get_assistant_subgraphs(
+    request: ApiRequest,
+) -> ApiResponse:
+    """Get an assistant by ID."""
+    assistant_id = request.path_params["assistant_id"]
+    validate_uuid(assistant_id, "Invalid assistant ID: must be a UUID")
+    async with connect() as conn:
+        assistant_ = await Assistants.get(conn, assistant_id)
+    assistant = await fetchone(assistant_)
+    config = await ajson_loads(assistant["config"])
+    graph = get_graph(assistant["graph_id"], config)
+    namespace = request.path_params.get("namespace")
+
+    if isinstance(graph, RemotePregel):
+        return ApiResponse(
+            await graph.fetch_subgraphs(
+                namespace=namespace,
+                recurse=request.query_params.get("recurse", "False")
+                in ("true", "True"),
+            )
+        )
+
+    return ApiResponse(
+        {
+            ns: _graph_schemas(subgraph)
+            async for ns, subgraph in graph.aget_subgraphs(
+                namespace=namespace,
+                recurse=request.query_params.get("recurse", "False")
+                in ("true", "True"),
+            )
+        }
+    )
+
+
+@retry_db
+async def get_assistant_schemas(
+    request: ApiRequest,
+) -> ApiResponse:
+    """Get an assistant by ID."""
+    assistant_id = request.path_params["assistant_id"]
+    validate_uuid(assistant_id, "Invalid assistant ID: must be a UUID")
+    async with connect() as conn:
+        assistant_ = await Assistants.get(conn, assistant_id)
+    assistant = await fetchone(assistant_)
+    config = await ajson_loads(assistant["config"])
+    graph = get_graph(assistant["graph_id"], config)
+
+    if isinstance(graph, RemotePregel):
+        schemas = await graph.fetch_state_schema()
+        return ApiResponse(
+            {
+                "graph_id": assistant["graph_id"],
+                "input_schema": schemas.get("input"),
+                "output_schema": schemas.get("output"),
+                "state_schema": schemas.get("state"),
+                "config_schema": schemas.get("config"),
+            }
+        )
+
+    try:
+        input_schema = graph.get_input_schema().schema()
+    except Exception:
+        input_schema = None
+    try:
+        output_schema = graph.get_output_schema().schema()
+    except Exception:
+        output_schema = None
+
+    state_schema = _state_jsonschema(graph)
+    try:
+        config_schema = (
+            graph.config_schema().__fields__["configurable"].annotation.schema()
+            if "configurable" in graph.config_schema().__fields__
+            else {}
+        )
+    except Exception:
+        config_schema = None
+    return ApiResponse(
+        {
+            "graph_id": assistant["graph_id"],
+            "input_schema": input_schema,
+            "output_schema": output_schema,
+            "state_schema": state_schema,
+            "config_schema": config_schema,
+        }
+    )
+
+
+@retry_db
+async def patch_assistant(
+    request: ApiRequest,
+) -> ApiResponse:
+    """Update an assistant."""
+    assistant_id = request.path_params["assistant_id"]
+    validate_uuid(assistant_id, "Invalid assistant ID: must be a UUID")
+    payload = await request.json(AssistantPatch)
+    async with connect() as conn:
+        assistant = await Assistants.patch(
+            conn,
+            assistant_id,
+            config=payload.get("config"),
+            graph_id=payload.get("graph_id"),
+            metadata=payload.get("metadata"),
+            name=payload.get("name"),
+        )
+    return ApiResponse(await fetchone(assistant))
+
+
+@retry_db
+async def delete_assistant(request: ApiRequest) -> ApiResponse:
+    """Delete an assistant by ID."""
+    assistant_id = request.path_params["assistant_id"]
+    validate_uuid(assistant_id, "Invalid assistant ID: must be a UUID")
+    async with connect() as conn:
+        aid = await Assistants.delete(conn, assistant_id)
+    await fetchone(aid)
+    return Response(status_code=204)
+
+
+@retry_db
+async def get_assistant_versions(request: ApiRequest) -> ApiResponse:
+    """Get all versions of an assistant."""
+    assistant_id = request.path_params["assistant_id"]
+    validate_uuid(assistant_id, "Invalid assistant ID: must be a UUID")
+    payload = await request.json(AssistantVersionsSearchRequest)
+    async with connect() as conn:
+        assistants_iter = await Assistants.get_versions(
+            conn,
+            assistant_id,
+            metadata=payload.get("metadata") or {},
+            limit=payload.get("limit") or 10,
+            offset=payload.get("offset") or 0,
+        )
+    return ApiResponse([assistant async for assistant in assistants_iter])
+
+
+@retry_db
+async def set_latest_assistant_version(request: ApiRequest) -> ApiResponse:
+    """Change the version of an assistant."""
+    assistant_id = request.path_params["assistant_id"]
+    payload = await request.json(AssistantVersionChange)
+    validate_uuid(assistant_id, "Invalid assistant ID: must be a UUID")
+    async with connect() as conn:
+        assistant = await Assistants.set_latest(
+            conn, assistant_id, payload.get("version")
+        )
+    return ApiResponse(await fetchone(assistant, not_found_code=404))
+
+
+assistants_routes: list[BaseRoute] = [
+    ApiRoute("/assistants", create_assistant, methods=["POST"]),
+    ApiRoute("/assistants/search", search_assistants, methods=["POST"]),
+    ApiRoute(
+        "/assistants/{assistant_id}/latest",
+        set_latest_assistant_version,
+        methods=["POST"],
+    ),
+    ApiRoute(
+        "/assistants/{assistant_id}/versions", get_assistant_versions, methods=["POST"]
+    ),
+    ApiRoute("/assistants/{assistant_id}", get_assistant, methods=["GET"]),
+    ApiRoute("/assistants/{assistant_id}/graph", get_assistant_graph, methods=["GET"]),
+    ApiRoute(
+        "/assistants/{assistant_id}/schemas", get_assistant_schemas, methods=["GET"]
+    ),
+    ApiRoute(
+        "/assistants/{assistant_id}/subgraphs", get_assistant_subgraphs, methods=["GET"]
+    ),
+    ApiRoute(
+        "/assistants/{assistant_id}/subgraphs/{namespace}",
+        get_assistant_subgraphs,
+        methods=["GET"],
+    ),
+    ApiRoute("/assistants/{assistant_id}", patch_assistant, methods=["PATCH"]),
+    ApiRoute("/assistants/{assistant_id}", delete_assistant, methods=["DELETE"]),
+]
+
+assistants_routes = [route for route in assistants_routes if route is not None]

langgraph_api/api/meta.py

@@ -0,0 +1,71 @@
+import os
+
+from starlette.responses import JSONResponse, PlainTextResponse
+
+from langgraph_api import config
+from langgraph_api.queue import WORKERS
+from langgraph_api.route import ApiRequest
+from langgraph_license.validation import plus_features_enabled
+from langgraph_storage.database import connect, pool_stats
+from langgraph_storage.ops import Runs
+
+METRICS_FORMATS = {"prometheus", "json"}
+
+
+async def meta_info(request: ApiRequest):
+    plus = plus_features_enabled()
+    return JSONResponse(
+        {
+            "flags": {
+                "assistants": True,
+                "crons": plus and config.FF_CRONS_ENABLED,
+            }
+        }
+    )
+
+
+async def meta_metrics(request: ApiRequest):
+    # determine output format
+    format = request.query_params.get("format", "prometheus")
+    if format not in METRICS_FORMATS:
+        format = "prometheus"
+
+    # collect stats
+    workers_max = config.N_JOBS_PER_WORKER
+    workers_active = len(WORKERS)
+    workers_available = workers_max - workers_active
+
+    if format == "json":
+        async with connect() as conn:
+            return JSONResponse(
+                {
+                    **pool_stats(),
+                    "workers": {
+                        "max": workers_max,
+                        "active": workers_active,
+                        "available": workers_available,
+                    },
+                    "queue": await Runs.stats(conn),
+                }
+            )
+    elif format == "prometheus":
+        # LANGSMITH_HOST_PROJECT_ID and HOSTED_LANGSERVE_REVISION_ID are injected
+        # into the deployed image by host-backend.
+        project_id = os.getenv("LANGSMITH_HOST_PROJECT_ID")
+        revision_id = os.getenv("HOSTED_LANGSERVE_REVISION_ID")
+
+        metrics = [
+            "# HELP lg_api_workers_max The maximum number of workers available.",
+            "# TYPE lg_api_workers_max gauge",
+            f'lg_api_workers_max{{project_id="{project_id}", revision_id="{revision_id}"}} {workers_max}',
+            "# HELP lg_api_workers_active The number of currently active workers.",
+            "# TYPE lg_api_workers_active gauge",
+            f'lg_api_workers_active{{project_id="{project_id}", revision_id="{revision_id}"}} {workers_active}',
+            "# HELP lg_api_workers_available The number of available (idle) workers.",
+            "# TYPE lg_api_workers_available gauge",
+            f'lg_api_workers_available{{project_id="{project_id}", revision_id="{revision_id}"}} {workers_available}',
+            # In the future, we can add more metrics to be scraped by Prometheus.
+        ]
+
+        metrics_response = "\n".join(metrics)
+        return PlainTextResponse(metrics_response)

langgraph_api/api/openapi.py

@@ -0,0 +1,32 @@
+from functools import lru_cache
+
+import orjson
+
+from langgraph_api.config import LANGGRAPH_AUTH_TYPE
+from langgraph_api.graph import GRAPHS
+from langgraph_api.validation import openapi
+
+
+@lru_cache(maxsize=1)
+def get_openapi_spec() -> str:
+    # patch the graph_id enums
+    graph_ids = list(GRAPHS.keys())
+    for schema in (
+        "Assistant",
+        "AssistantCreate",
+        "AssistantPatch",
+        "GraphSchema",
+        "AssistantSearchRequest",
+    ):
+        openapi["components"]["schemas"][schema]["properties"]["graph_id"]["enum"] = (
+            graph_ids
+        )
+    # patch the auth schemes
+    if LANGGRAPH_AUTH_TYPE == "langsmith":
+        openapi["security"] = [
+            {"x-api-key": []},
+        ]
+        openapi["components"]["securitySchemes"] = {
+            "x-api-key": {"type": "apiKey", "in": "header", "name": "x-api-key"}
+        }
+    return orjson.dumps(openapi)