langgraph-api 0.0.31__tar.gz → 0.0.33__tar.gz

{langgraph_api-0.0.31 → langgraph_api-0.0.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langgraph-api
-Version: 0.0.31
+Version: 0.0.33
 Summary: 
 License: Elastic-2.0
 Author: Nuno Campos
@@ -16,7 +16,7 @@ Requires-Dist: jsonschema-rs (>=0.20.0,<0.30)
 Requires-Dist: langchain-core (>=0.2.38,<0.4.0)
 Requires-Dist: langgraph (>=0.2.56,<0.4.0)
 Requires-Dist: langgraph-checkpoint (>=2.0.21,<3.0)
-Requires-Dist: langgraph-sdk (>=0.1.57,<0.2.0)
+Requires-Dist: langgraph-sdk (>=0.1.58,<0.2.0)
 Requires-Dist: langsmith (>=0.1.63,<0.4.0)
 Requires-Dist: orjson (>=3.9.7)
 Requires-Dist: pyjwt (>=2.9.0,<3.0.0)

{langgraph_api-0.0.31 → langgraph_api-0.0.33}/langgraph_api/api/__init__.py

@@ -10,6 +10,7 @@ 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.mcp import mcp_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
@@ -66,6 +67,11 @@ if HTTP_CONFIG:
         protected_routes.extend(store_routes)
     if not HTTP_CONFIG.get("disable_ui"):
         protected_routes.extend(ui_routes)
+    # Default for disabling MCP. Until we can verify that the protocol is working
+    # correctly. This is dependent on the release of an official MCP client
+    # implementation.
+    if not HTTP_CONFIG.get("disable_mcp", True):
+        protected_routes.extend(mcp_routes)
 else:
     protected_routes.extend(assistants_routes)
     protected_routes.extend(runs_routes)

{langgraph_api-0.0.31 → langgraph_api-0.0.33}/langgraph_api/api/assistants.py

@@ -87,7 +87,13 @@ def _graph_schemas(graph: Pregel) -> dict:
             f"Failed to get output schema for graph {graph.name} with error: `{str(e)}`"
         )
         output_schema = None
-    state_schema = _state_jsonschema(graph)
+    try:
+        state_schema = _state_jsonschema(graph)
+    except Exception as e:
+        logger.warning(
+            f"Failed to get state schema for graph {graph.name} with error: `{str(e)}`"
+        )
+        state_schema = None
     try:
         config_schema = _get_configurable_jsonschema(graph)
     except Exception as e:

langgraph_api-0.0.33/langgraph_api/api/mcp.py

@@ -0,0 +1,467 @@
+"""Implement MCP endpoint for Streamable HTTP protocol.
+
+The current version of the RFC can be found here:
+
+https://github.com/modelcontextprotocol/specification/blob/0f4924b07447073cbe1e29fbe64e42d379b52b04/docs/specification/draft/basic/transports.md#streamable-http
+
+Tools specification:
+
+https://github.com/modelcontextprotocol/specification/blob/0f4924b07447073cbe1e29fbe64e42d379b52b04/docs/specification/draft/server/tools.md
+
+Message format:
+
+https://github.com/modelcontextprotocol/specification/blob/0f4924b07447073cbe1e29fbe64e42d379b52b04/docs/specification/draft/basic/messages.md
+
+Error handling with tools:
+
+https://github.com/modelcontextprotocol/specification/blob/0f4924b07447073cbe1e29fbe64e42d379b52b04/docs/specification/draft/server/tools.md#error-handling
+
+Streamable HTTP is a protocol that allows for the use of HTTP as transport.
+
+The protocol supports both stateless and stateful interactions, and allows
+the server to respond via either Application/JSON or text/event-stream.
+
+LangGraph's implementation is currently stateless and only uses Application/JSON.
+
+1. Adding stateful sessions: A stateful session would in theory allow agents used
+as tools to remember past interactions. We likely do not want to map a session
+to a thread ID as a single session may involve more than one tool call.
+We would need to map a session to a collection of threads.
+
+2. text/event-stream (SSE): Should be simple to add we'd want to make sure
+we know what information we want to stream; e.g., progress notifications or
+custom notifications.
+
+In addition, the server could support resumability by allowing clients to specify
+a Last-Event-ID in the request headers.
+"""
+
+import functools
+import json
+from typing import Any, NotRequired, cast
+
+from langgraph_sdk.client import LangGraphClient, get_client
+from starlette.responses import JSONResponse, Response
+from structlog import getLogger
+from typing_extensions import TypedDict
+
+from langgraph_api.route import ApiRequest, ApiRoute
+
+logger = getLogger(__name__)
+
+
+class JsonRpcErrorObject(TypedDict):
+    code: int
+    message: str
+    data: NotRequired[Any]
+
+
+class JsonRpcRequest(TypedDict):
+    jsonrpc: str  # Must be "2.0"
+    id: str | int
+    method: str
+    params: NotRequired[dict[str, Any]]
+
+
+class JsonRpcResponse(TypedDict):
+    jsonrpc: str  # Must be "2.0"
+    id: str | int
+    result: NotRequired[dict[str, Any]]
+    error: NotRequired[JsonRpcErrorObject]
+
+
+class JsonRpcNotification(TypedDict):
+    jsonrpc: str  # Must be "2.0"
+    method: str
+    params: NotRequired[dict[str, Any]]
+
+
+@functools.lru_cache(maxsize=1)
+def _client() -> LangGraphClient:
+    """Get a client for local operations."""
+    return get_client(url=None)
+
+
+# Workaround assistant name not exposed in the Assistants.search API
+MAX_ASSISTANTS = 1000
+DEFAULT_PAGE_SIZE = 100
+
+# JSON-RPC error codes: https://www.jsonrpc.org/specification#error_object
+ERROR_CODE_INVALID_PARAMS = -32602
+ERROR_CODE_METHOD_NOT_FOUND = -32601
+
+
+async def handle_mcp_endpoint(request: ApiRequest) -> Response:
+    """MCP endpoint handler the implements the Streamable HTTP protocol.
+
+    The handler is expected to support the following methods:
+
+    - POST: Process a JSON-RPC request
+    - DELETE: Terminate a session
+
+    We currently do not support:
+    - /GET (initiates a streaming session)
+        This endpoint can be used to RESUME a previously interrupted session.
+    - text/event-stream (streaming) response from the server.
+
+    Support for these can be added, we just need to determine what information
+    from the agent we want to stream.
+
+    One possibility is to map "custom" stream mode to server side notifications.
+
+    Args:
+        request: The incoming request object
+
+    Returns:
+        The response to the request
+    """
+    # Route request based on HTTP method
+    if request.method == "DELETE":
+        return handle_delete_request()
+    elif request.method == "GET":
+        return handle_get_request()
+    elif request.method == "POST":
+        return await handle_post_request(request)
+    else:
+        # Method not allowed
+        return Response(status_code=405)
+
+
+def handle_delete_request() -> Response:
+    """Handle HTTP DELETE requests for session termination.
+
+    Returns:
+        Response with appropriate status code
+    """
+    return Response(status_code=404)
+
+
+def handle_get_request() -> Response:
+    """Handle HTTP GET requests for streaming (not currently supported).
+
+    Returns:
+        Method not allowed response
+    """
+    # Does not support streaming at the moment
+    return Response(status_code=405)
+
+
+async def handle_post_request(request: ApiRequest) -> Response:
+    """Handle HTTP POST requests for JSON-RPC messaging.
+
+    Args:
+        request: The incoming request object
+
+    Returns:
+        Response to the JSON-RPC message
+    """
+    body = await request.body()
+
+    # Validate JSON
+    try:
+        message = json.loads(body)
+    except json.JSONDecodeError:
+        return create_error_response("Invalid JSON", 400)
+
+    # Validate Accept header
+    if not is_valid_accept_header(request):
+        return create_error_response(
+            "Accept header must include application/json or text/event-stream", 400
+        )
+
+    # Validate message format
+    if not isinstance(message, dict):
+        return create_error_response("Invalid message format.", 400)
+
+    # Determine message type and route to appropriate handler
+    id_ = message.get("id")
+    method = message.get("method")
+
+    # Check for required jsonrpc field
+    if message.get("jsonrpc") != "2.0":
+        return create_error_response(
+            "Invalid JSON-RPC message. Missing or invalid jsonrpc version.", 400
+        )
+
+    if id_ and method:
+        # JSON-RPC request
+        return await handle_jsonrpc_request(request, cast(JsonRpcRequest, message))
+    elif id_:
+        # JSON-RPC response
+        return handle_jsonrpc_response(cast(JsonRpcResponse, message))
+    elif method:
+        # JSON-RPC notification
+        return handle_jsonrpc_notification(cast(JsonRpcNotification, message))
+    else:
+        # Invalid message format
+        return create_error_response(
+            "Invalid message format. A message is to be either a JSON-RPC "
+            "request, response, or notification."
+            "Please see the Messages section of the Streamable HTTP RFC "
+            "for more information.",
+            400,
+        )
+
+
+def is_valid_accept_header(request: ApiRequest) -> bool:
+    """Check if the Accept header contains supported content types.
+
+    Args:
+        request: The incoming request
+
+    Returns:
+        True if header contains application/json or text/event-stream
+    """
+    accept_header = request.headers.get("Accept", "")
+    accepts_json = "application/json" in accept_header
+    accepts_sse = "text/event-stream" in accept_header
+    return accepts_json or accepts_sse
+
+
+def create_error_response(message: str, status_code: int) -> Response:
+    """Create a JSON error response.
+
+    Args:
+        message: The error message
+        status_code: The HTTP status code
+
+    Returns:
+        JSON response with error details
+    """
+    return Response(
+        content=json.dumps({"error": message}),
+        status_code=status_code,
+        media_type="application/json",
+    )
+
+
+async def handle_jsonrpc_request(
+    request: ApiRequest,
+    message: JsonRpcRequest,
+) -> Response:
+    """Handle JSON-RPC requests (messages with both id and method).
+
+    Args:
+        request: The incoming request object
+        message: The parsed JSON-RPC message
+
+    Returns:
+        Response to the request
+    """
+    method = message["method"]
+    params = message.get("params", {})
+
+    if method == "initialize":
+        result_or_error = handle_initialize_request(message)
+    elif method == "tools/list":
+        result_or_error = await handle_tools_list(request, params)
+    elif method == "tools/call":
+        result_or_error = await handle_tools_call(request, params)
+    else:
+        result_or_error = {
+            "error": {
+                "code": ERROR_CODE_METHOD_NOT_FOUND,
+                "message": f"Method not found: {method}",
+            }
+        }
+
+    # Process the result or error output
+    exists = {"error", "result"} - set(result_or_error.keys())
+    if len(exists) != 1:
+        raise AssertionError(
+            "Internal server error. Invalid response in MCP protocol implementation."
+        )
+
+    return JSONResponse(
+        {
+            "jsonrpc": "2.0",
+            "id": message["id"],
+            **result_or_error,
+        }
+    )
+
+
+def handle_initialize_request(message: JsonRpcRequest) -> dict[str, Any]:
+    """Handle initialize requests to create a new session.
+
+    Args:
+        message: The JSON-RPC request message
+
+    Returns:
+        Response with new session details
+    """
+    return {
+        "result": {
+            # We do not return a session ID right now.
+            "capabilities": {
+                "tools": {
+                    # We do not support subscriptions currently
+                    "listChanged": False,
+                },
+            },
+        },
+    }
+
+
+def handle_jsonrpc_response(message: JsonRpcResponse) -> Response:
+    """Handle JSON-RPC responses (messages with id but no method).
+
+    Args:
+        message: The parsed JSON-RPC response message
+
+    Returns:
+        Acknowledgement response
+    """
+    # For any responses, we just acknowledge receipt
+    return Response(status_code=202)
+
+
+def handle_jsonrpc_notification(message: JsonRpcNotification) -> Response:
+    """Handle JSON-RPC notifications (messages with method but no id).
+
+    Args:
+        message: The parsed JSON-RPC message
+
+    Returns:
+        Response to the notification
+    """
+    return Response(status_code=202)
+
+
+async def handle_tools_list(
+    request: ApiRequest, params: dict[str, Any]
+) -> dict[str, Any]:
+    """Handle tools/list request to get available assistants as tools.
+
+    Args:
+        request: The incoming request object. Used for propagating any headers
+                 for authentication purposes.
+        params: The parameters for the tools/list request
+
+    Returns:
+        Dictionary containing list of available tools
+    """
+    client = _client()
+
+    try:
+        cursor = params.get("cursor", 0)
+        cursor = int(cursor)
+    except ValueError:
+        cursor = 0
+
+    # Get assistants from the API
+    # For now set a large limit to get all assistants
+    assistants = await client.assistants.search(offset=cursor, limit=DEFAULT_PAGE_SIZE)
+
+    if len(assistants) == DEFAULT_PAGE_SIZE:
+        next_cursor = cursor + DEFAULT_PAGE_SIZE
+    else:
+        next_cursor = None
+
+    # Format assistants as tools for MCP
+    tools = []
+    seen_names = set()
+    for assistant in assistants:
+        id_ = assistant.get("assistant_id")
+        name = assistant["name"]
+
+        if name in seen_names:
+            await logger.awarning(f"Duplicate assistant name found {name}", name=name)
+        else:
+            seen_names.add(name)
+
+        schemas = await client.assistants.get_schemas(id_)
+        tools.append(
+            {
+                "name": name,
+                "inputSchema": schemas.get("input_schema", {}),
+                "description": "",
+            },
+        )
+    return {"result": {"tools": tools, "nextCursor": next_cursor}}
+
+
+async def handle_tools_call(
+    request: ApiRequest, params: dict[str, Any]
+) -> dict[str, Any]:
+    """Handle tools/call request to execute an assistant.
+
+    Args:
+        request: The incoming request
+        params: The parameters for the tool call
+
+    Returns:
+        The result of the tool execution
+    """
+    client = _client()
+
+    tool_name = params.get("name")
+
+    if not tool_name:
+        return {
+            "jsonrpc": "2.0",
+            "id": 3,
+            "error": {
+                "code": ERROR_CODE_INVALID_PARAMS,
+                "message": f"Unknown tool: {tool_name}",
+            },
+        }
+
+    arguments = params.get("arguments", {})
+    assistants = await client.assistants.search(limit=MAX_ASSISTANTS)
+    matching_assistant = [
+        assistant for assistant in assistants if assistant["name"] == tool_name
+    ]
+
+    num_assistants = len(matching_assistant)
+
+    if num_assistants == 0:
+        return {
+            "jsonrpc": "2.0",
+            "id": 3,
+            "error": {
+                "code": ERROR_CODE_INVALID_PARAMS,
+                "message": f"Unknown tool: {tool_name}",
+            },
+        }
+    elif num_assistants > 1:
+        return {
+            "jsonrpc": "2.0",
+            "id": 3,
+            "error": {
+                "code": ERROR_CODE_INVALID_PARAMS,
+                "message": "Multiple tools found with the same name.",
+            },
+        }
+    else:
+        tool_name = matching_assistant[0]["assistant_id"]
+
+    value = await client.runs.wait(
+        thread_id=None, assistant_id=tool_name, input=arguments, raise_error=False
+    )
+
+    if "__error__" in value:
+        # This is a run-time error in the tool.
+        return {
+            "result": {
+                "isError": True,
+                "content": [
+                    {"type": "text", "value": value["__error__"]["error"]},
+                ],
+            }
+        }
+
+    # All good, return the result
+    return {
+        "result": {
+            "content": [
+                {"type": "text", "value": repr(value)},
+            ]
+        }
+    }
+
+
+# Define routes for the MCP endpoint
+mcp_routes = [
+    ApiRoute("/mcp", handle_mcp_endpoint, methods=["GET", "POST", "DELETE"]),
+]

{langgraph_api-0.0.31 → langgraph_api-0.0.33}/langgraph_api/api/threads.py

@@ -28,12 +28,21 @@ async def create_thread(
     if thread_id := payload.get("thread_id"):
         validate_uuid(thread_id, "Invalid thread ID: must be a UUID")
     async with connect() as conn:
+        thread_id = thread_id or str(uuid4())
         iter = await Threads.put(
             conn,
-            thread_id or uuid4(),
+            thread_id,
             metadata=payload.get("metadata"),
             if_exists=payload.get("if_exists") or "raise",
         )
+
+        if supersteps := payload.get("supersteps"):
+            await Threads.State.bulk(
+                conn,
+                config={"configurable": {"thread_id": thread_id}},
+                supersteps=supersteps,
+            )
+
     return ApiResponse(await fetchone(iter, not_found_code=409))
 
 

{langgraph_api-0.0.31 → langgraph_api-0.0.33}/langgraph_api/asyncio.py

@@ -1,4 +1,5 @@
 import asyncio
+import concurrent.futures
 from collections.abc import AsyncIterator, Coroutine
 from contextlib import AbstractAsyncContextManager
 from functools import partial
@@ -10,6 +11,13 @@ T = TypeVar("T")
 
 logger = structlog.stdlib.get_logger(__name__)
 
+_MAIN_LOOP: asyncio.AbstractEventLoop | None = None
+
+
+def set_event_loop(loop: asyncio.AbstractEventLoop) -> None:
+    global _MAIN_LOOP
+    _MAIN_LOOP = loop
+
 
 async def sleep_if_not_done(delay: float, done: asyncio.Event) -> None:
     try:
@@ -76,9 +84,10 @@ PENDING_TASKS = set()
 
 
 def _create_task_done_callback(
-    ignore_exceptions: tuple[Exception, ...], task: asyncio.Task
+    ignore_exceptions: tuple[Exception, ...],
+    task: asyncio.Task | asyncio.Future,
 ) -> None:
-    PENDING_TASKS.remove(task)
+    PENDING_TASKS.discard(task)
     try:
         if exc := task.exception():
             if not isinstance(exc, ignore_exceptions):
@@ -97,6 +106,16 @@ def create_task(
     return task
 
 
+def run_coroutine_threadsafe(
+    coro: Coroutine[Any, Any, T], ignore_exceptions: tuple[type[Exception], ...] = ()
+) -> concurrent.futures.Future[T | None]:
+    if _MAIN_LOOP is None:
+        raise RuntimeError("No event loop set")
+    future = asyncio.run_coroutine_threadsafe(coro, _MAIN_LOOP)
+    future.add_done_callback(partial(_create_task_done_callback, ignore_exceptions))
+    return future
+
+
 class SimpleTaskGroup(AbstractAsyncContextManager["SimpleTaskGroup"]):
     """An async task group that can be configured to wait and/or cancel tasks on exit.
 

{langgraph_api-0.0.31 → langgraph_api-0.0.33}/langgraph_api/cli.py

@@ -129,6 +129,7 @@ def run_server(
     store: typing.Optional["StoreConfig"] = None,
     auth: AuthConfig | None = None,
     http: typing.Optional["HttpConfig"] = None,
+    studio_url: str | None = None,
     **kwargs: typing.Any,
 ):
     """Run the LangGraph API server."""
@@ -188,15 +189,16 @@ def run_server(
         LANGSMITH_LANGGRAPH_API_VARIANT="local_dev",
         LANGGRAPH_AUTH=json.dumps(auth) if auth else None,
         LANGGRAPH_HTTP=json.dumps(http) if http else None,
+        LANGGRAPH_API_URL=local_url,
         # See https://developer.chrome.com/blog/private-network-access-update-2024-03
         ALLOW_PRIVATE_NETWORK="true",
         **(env_vars or {}),
     ):
-        studio_origin = _get_ls_origin() or "https://smith.langchain.com"
-        studio_url = f"{studio_origin}/studio/?baseUrl={local_url}"
+        studio_origin = studio_url or _get_ls_origin() or "https://smith.langchain.com"
+        full_studio_url = f"{studio_origin}/studio/?baseUrl={local_url}"
 
         def _open_browser():
-            nonlocal studio_origin, studio_url
+            nonlocal studio_origin, full_studio_url
             import time
             import urllib.request
             import webbrowser
@@ -218,7 +220,7 @@ def run_server(
                                 try:
                                     org_id = org_id_future.result(timeout=3.0)
                                     if org_id:
-                                        studio_url = f"{studio_origin}/studio/?baseUrl={local_url}&organizationId={org_id}"
+                                        full_studio_url = f"{studio_origin}/studio/?baseUrl={local_url}&organizationId={org_id}"
                                 except TimeoutError as e:
                                     thread_logger.debug(
                                         f"Failed to get organization ID: {str(e)}"
@@ -230,8 +232,8 @@ def run_server(
                                 thread_logger.info(
                                     "🎨 Opening Studio in your browser..."
                                 )
-                                thread_logger.info("URL: " + studio_url)
-                                webbrowser.open(studio_url)
+                                thread_logger.info("URL: " + full_studio_url)
+                                webbrowser.open(full_studio_url)
                                 return
                     except urllib.error.URLError:
                         pass
@@ -246,7 +248,7 @@ def run_server(
 ╩═╝┴ ┴┘└┘└─┘╚═╝┴└─┴ ┴┴  ┴ ┴
 
 - 🚀 API: \033[36m{local_url}\033[0m
-- 🎨 Studio UI: \033[36m{studio_url}\033[0m
+- 🎨 Studio UI: \033[36m{full_studio_url}\033[0m
 - 📚 API Docs: \033[36m{local_url}/docs\033[0m
 
 This in-memory server is designed for development and testing.

langgraph_api-0.0.33/langgraph_api/command.py

@@ -0,0 +1,29 @@
+from langgraph.types import Command, Send
+
+from langgraph_api.schema import RunCommand
+
+
+def map_cmd(cmd: RunCommand) -> Command:
+    goto = cmd.get("goto")
+    if goto is not None and not isinstance(goto, list):
+        goto = [cmd.get("goto")]
+
+    update = cmd.get("update")
+    if isinstance(update, tuple | list) and all(
+        isinstance(t, tuple | list) and len(t) == 2 and isinstance(t[0], str)
+        for t in update
+    ):
+        update = [tuple(t) for t in update]
+
+    return Command(
+        update=update,
+        goto=(
+            [
+                it if isinstance(it, str) else Send(it["node"], it["input"])
+                for it in goto
+            ]
+            if goto
+            else None
+        ),
+        resume=cmd.get("resume"),
+    )

{langgraph_api-0.0.31 → langgraph_api-0.0.33}/langgraph_api/config.py

@@ -32,6 +32,11 @@ class HttpConfig(TypedDict, total=False):
     disable_meta: bool
     """Disable /ok, /info, /metrics, and /docs routes"""
     cors: CorsConfig | None
+    """CORS configuration"""
+    disable_ui: bool
+    """Disable /ui routes"""
+    disable_mcp: bool
+    """Disable /mcp routes"""
 
 
 class IndexConfig(TypedDict, total=False):