langgraph-api 0.2.83__tar.gz → 0.2.86__tar.gz

{langgraph_api-0.2.83 → langgraph_api-0.2.86}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.2.83
+Version: 0.2.86
 Author-email: Nuno Campos <nuno@langchain.dev>, Will Fu-Hinthorn <will@langchain.dev>
 License: Elastic-2.0
 License-File: LICENSE

{langgraph_api-0.2.83 → langgraph_api-0.2.86}/benchmark/Makefile

@@ -2,5 +2,8 @@
 benchmark-burst:
 	k6 run burst.js
 
+benchmark-ramp:
+	k6 run ramp.js
+
 benchmark-clean:
 	rm -f results_*.json summary_*.json

langgraph_api-0.2.86/benchmark/README.md

@@ -0,0 +1,72 @@
+# K6 Performance Testing
+
+K6 is a modern load testing tool that allows you to test the performance and reliability of your APIs. The tests in this directory are designed to validate the performance characteristics of the LangGraph API under various load conditions.
+
+## Test Scenarios
+
+### Available Tests
+
+There are two modes of testing available:
+1. `Burst` - Kick off a burst of /run/wait requests. 
+    Available Params:
+        BURST_SIZE - How many requests to run. Default: 100
+2. `Ramp` - Scale up the number of /run/wait requests and then plateau.
+    Available Params:
+        LOAD_SIZE - How much traffic to ramp up over a 60s period. Default: 100
+        LEVELS - The number of times to ramp up. Default: 10
+        PLATEAU_DURATION - How long to sustain the max level of traffic in seconds. Default: 300
+
+### Agent
+
+We use a local benchmark agent that can be configured to run a number of different test scenarios to simulate a variety of graphs.
+
+Available Params:
+    DATA_SIZE - How many characters each message should have in a parallel or sequence node. Default: 1000
+    DELAY - How long to sleep in each parallel or sequence node. Default: 0
+    EXPAND - How many nodes to run in the parallel or sequence modes. Default: 50
+    MODE - What configuration to run the graph. Default: single
+        - `single` - Run a single node
+        - `parallel` - Run EXPAND nodes in parallel
+        - `sequential` - Run EXPAND nodes in sequence
+
+## Running Tests
+
+### Local Prerequisites
+
+1. Install k6: https://k6.io/docs/getting-started/installation/
+2. Start your LangGraph API service
+3. Ensure the API is accessible at `http://localhost:9123`
+
+### Remote Prerequisites
+
+1. Get a LangSmith API Key: https://docs.smith.langchain.com/administration/how_to_guides/organization_management/create_account_api_key#create-an-api-key
+2. The deployment jdr-benchmark is setup for this. Endpoint: https://jdr-benchmark-1cfe27c4cd375e1c999f02f186f617f6.us.langgraph.app
+
+### Basic Usage
+
+```bash
+# Run burst test with default burst size
+make benchmark-burst
+
+# Run burst test with custom burst size
+BURST_SIZE=500 make benchmark-burst
+
+# Run ramp test with a different mode and expand size
+MODE='parallel' EXPAND=100 make benchmark-ramp
+
+# Run burst test against a deployment
+BASE_URL=https://jdr-benchmark-1cfe27c4cd375e1c999f02f186f617f6.us.langgraph.app make benchmark-burst
+
+# Clean up result files
+make benchmark-clean
+```
+
+### Output
+
+Summary results are written to stdout and persisted in a summary_burst file. More detailed results for the same burst are persisted in a results_burst file.
+
+## Resources
+
+- [K6 Documentation](https://k6.io/docs/)
+- [K6 JavaScript API](https://k6.io/docs/javascript-api/)
+- [Performance Testing Best Practices](https://k6.io/docs/testing-guides/) 

{langgraph_api-0.2.83 → langgraph_api-0.2.86}/benchmark/burst.js

@@ -15,9 +15,17 @@ const burstSuccessRate = new Rate('burst_success_rate');
 
 // URL of your LangGraph server
 const BASE_URL = __ENV.BASE_URL || 'http://localhost:9123';
+// LangSmith API key only needed with a custom server endpoint
+const LANGSMITH_API_KEY = __ENV.LANGSMITH_API_KEY;
+
+// Params for the runner
 const BURST_SIZE = parseInt(__ENV.BURST_SIZE || '100');
-const MODE = __ENV.MODE || 'single';
+
+// Params for the agent
+const DATA_SIZE = parseInt(__ENV.DATA_SIZE || '1000');
+const DELAY = parseInt(__ENV.DELAY || '0');
 const EXPAND = parseInt(__ENV.EXPAND || '50');
+const MODE = __ENV.MODE || 'single';
 
 // Burst testing configuration
 export let options = {
@@ -31,7 +39,7 @@ export let options = {
   },
   thresholds: {
     'run_duration': ['p(95)<2000'],
-    'burst_success_rate': ['rate>0.99'],
+    'burst_success_rate': ['rate>=0.99'],
   },
 };
 
@@ -48,11 +56,19 @@ export default function() {
 
     // Prepare the request payload
     const headers = { 'Content-Type': 'application/json' };
+    if (LANGSMITH_API_KEY) {
+      headers['x-api-key'] = LANGSMITH_API_KEY;
+    }
 
     // Create a payload with the LangGraph agent configuration
     const payload = JSON.stringify({
       assistant_id: "benchmark",
-      input: {mode: MODE, expand: EXPAND},
+      input: {
+        data_size: DATA_SIZE,
+        delay: DELAY,
+        expand: EXPAND,
+        mode: MODE,
+      },
       config: {
         recursion_limit: EXPAND + 2,
       }

langgraph_api-0.2.86/benchmark/ramp.js

@@ -0,0 +1,178 @@
+import http from 'k6/http';
+import { check, sleep } from 'k6';
+import { Counter, Trend } from 'k6/metrics';
+import { randomIntBetween } from 'https://jslib.k6.io/k6-utils/1.2.0/index.js';
+
+// Custom metrics
+const runDuration = new Trend('run_duration');
+const successfulRuns = new Counter('successful_runs');
+const failedRuns = new Counter('failed_runs');
+const timeoutErrors = new Counter('timeout_errors');
+const connectionErrors = new Counter('connection_errors');
+const serverErrors = new Counter('server_errors');
+const otherErrors = new Counter('other_errors');
+
+// URL of your LangGraph server
+const BASE_URL = __ENV.BASE_URL || 'http://localhost:9123';
+// LangSmith API key only needed with a custom server endpoint
+const LANGSMITH_API_KEY = __ENV.LANGSMITH_API_KEY;
+
+// Params for the runner
+const LOAD_SIZE = parseInt(__ENV.LOAD_SIZE || '100');
+const LEVELS = parseInt(__ENV.LEVELS || '10');
+const PLATEAU_DURATION = parseInt(__ENV.PLATEAU_DURATION || '300');
+
+// Params for the agent
+const DATA_SIZE = parseInt(__ENV.DATA_SIZE || '1000');
+const DELAY = parseInt(__ENV.DELAY || '0');
+const EXPAND = parseInt(__ENV.EXPAND || '50');
+const MODE = __ENV.MODE || 'single';
+
+const stages = [];
+for (let i = 1; i <= LEVELS; i++) {
+  stages.push({ duration: '60s', target: LOAD_SIZE * i });
+}
+stages.push({ duration: `${PLATEAU_DURATION}s`, target: LOAD_SIZE * LEVELS});
+stages.push({ duration: '30s', target: 0 }); // Ramp down
+
+// Test configuration
+export let options = {
+  scenarios: {
+    constant_load: {
+      executor: 'ramping-vus',
+      startVUs: 1,
+      stages,
+      gracefulRampDown: '120s',
+    },
+  },
+  thresholds: {
+    'run_duration': ['p(95)<30000'],  // 95% of runs should complete within 30s
+    'successful_runs': ['count>100'],  // At least 100 successful runs
+    'http_req_failed': ['rate<0.2'],   // Error rate should be less than 20%
+  },
+};
+
+// Main test function
+export default function() {
+  const startTime = new Date().getTime();
+
+  try {
+    // Prepare the request payload
+    const headers = { 'Content-Type': 'application/json' };
+    if (LANGSMITH_API_KEY) {
+      headers['x-api-key'] = LANGSMITH_API_KEY;
+    }
+
+    // Create a payload with the LangGraph agent configuration
+    const payload = JSON.stringify({
+        assistant_id: "benchmark",
+        input: {
+          data_size: DATA_SIZE,
+          delay: DELAY,
+          expand: EXPAND,
+          mode: MODE,
+        },
+        config: {
+          recursion_limit: EXPAND + 2,
+        },
+      });
+
+    // Make a single request to the wait endpoint
+    const response = http.post(`${BASE_URL}/runs/wait`, payload, {
+      headers,
+      timeout: '120s'  // k6 request timeout slightly longer than the server timeout
+    });
+
+    // Don't include verification in the duration of the request
+    const duration = new Date().getTime() - startTime;
+
+    // Check the response
+    const expected_length = MODE === 'single' ? 1 : EXPAND + 1;
+    const success = check(response, {
+      'Run completed successfully': (r) => r.status === 200,
+      'Response contains expected number of messages': (r) => JSON.parse(r.body).messages.length === expected_length,
+    });
+
+    if (success) {
+      // Record success metrics
+      runDuration.add(duration);
+      successfulRuns.add(1);
+
+      // Optional: Log successful run details
+      console.log(`Run completed successfully in ${duration/1000}s`);
+    } else {
+      // Handle failure
+      failedRuns.add(1);
+
+      // Classify error based on status code or response
+      if (response.status >= 500) {
+        serverErrors.add(1);
+        console.log(`Server error: ${response.status}`);
+      } else if (response.status === 408 || response.error === 'timeout') {
+        timeoutErrors.add(1);
+        console.log(`Timeout error: ${response.error}`);
+      } else {
+        otherErrors.add(1);
+        console.log(`Other error: Status ${response.status}, ${JSON.stringify(response)}`);
+      }
+    }
+
+  } catch (error) {
+    // Handle exceptions (network errors, etc.)
+    failedRuns.add(1);
+
+    if (error.message.includes('timeout')) {
+      timeoutErrors.add(1);
+      console.log(`Timeout error: ${error.message}`);
+    } else if (error.message.includes('connection') || error.message.includes('network')) {
+      connectionErrors.add(1);
+      console.log(`Connection error: ${error.message}`);
+    } else {
+      otherErrors.add(1);
+      console.log(`Unexpected error: ${error.message}`);
+    }
+  }
+
+  // Add a small random sleep between iterations to prevent thundering herd
+  sleep(randomIntBetween(0.2, 0.5) / 1.0);
+}
+
+// Setup function
+export function setup() {
+  console.log(`Starting ramp benchmark`);
+  console.log(`Running on pod: ${__ENV.POD_NAME || 'local'}`);
+  console.log(`Running ${LEVELS} levels with base size ${LOAD_SIZE}`);
+
+  return { startTime: new Date().toISOString() };
+}
+
+// Handle summary
+export function handleSummary(data) {
+  const timestamp = new Date().toISOString().replace(/:/g, '-').replace(/\..+/, '');
+
+  // Create summary information with aggregated metrics
+  const summary = {
+    timestamp: timestamp,
+    metrics: {
+      totalRuns: data.metrics.successful_runs.values.count + data.metrics.failed_runs.values.count,
+      successfulRuns: data.metrics.successful_runs.values.count,
+      failedRuns: data.metrics.failed_runs.values.count,
+      successRate: data.metrics.successful_runs.values.count /
+                  (data.metrics.successful_runs.values.count + data.metrics.failed_runs.values.count) * 100,
+      averageDuration: data.metrics.run_duration.values.avg / 1000,  // in seconds
+      p95Duration: data.metrics.run_duration.values["p(95)"] / 1000, // in seconds
+      errors: {
+        timeout: data.metrics.timeout_errors ? data.metrics.timeout_errors.values.count : 0,
+        connection: data.metrics.connection_errors ? data.metrics.connection_errors.values.count : 0,
+        server: data.metrics.server_errors ? data.metrics.server_errors.values.count : 0,
+        other: data.metrics.other_errors ? data.metrics.other_errors.values.count : 0
+      }
+    }
+  };
+
+  return {
+    [`results_${timestamp}.json`]: JSON.stringify(data, null, 2),
+    [`summary_${timestamp}.json`]: JSON.stringify(summary, null, 2),
+    stdout: JSON.stringify(summary, null, 2)  // Also print summary to console
+  };
+}

langgraph_api-0.2.86/langgraph_api/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.86"

{langgraph_api-0.2.83 → langgraph_api-0.2.86}/langgraph_api/api/mcp.py

@@ -385,11 +385,12 @@ async def handle_tools_list(
             seen_names.add(name)
 
         schemas = await client.assistants.get_schemas(id_, headers=request.headers)
+        description = assistant.get("description") or ""
         tools.append(
             {
                 "name": name,
                 "inputSchema": schemas.get("input_schema", {}),
-                "description": "",
+                "description": description,
             },
         )
 

{langgraph_api-0.2.83 → langgraph_api-0.2.86}/langgraph_api/api/meta.py

@@ -1,3 +1,4 @@
+import langgraph.version
 from starlette.responses import JSONResponse, PlainTextResponse
 
 from langgraph_api import __version__, config, metadata
@@ -16,6 +17,7 @@ async def meta_info(request: ApiRequest):
     return JSONResponse(
         {
             "version": __version__,
+            "langgraph_py_version": langgraph.version.__version__,
             "flags": {
                 "assistants": True,
                 "crons": plus and config.FF_CRONS_ENABLED,

{langgraph_api-0.2.83 → langgraph_api-0.2.86}/langgraph_api/api/runs.py

@@ -172,6 +172,7 @@ async def wait_run(request: ApiRequest):
     """Create a run, wait for the output."""
     thread_id = request.path_params["thread_id"]
     payload = await request.json(RunCreateStateful)
+    on_disconnect = payload.get("on_disconnect", "continue")
     run_id = uuid6()
     sub = asyncio.create_task(Runs.Stream.subscribe(run_id))
 
@@ -197,7 +198,10 @@ async def wait_run(request: ApiRequest):
         vchunk: bytes | None = None
         async with aclosing(
             Runs.Stream.join(
-                run["run_id"], thread_id=run["thread_id"], stream_mode=await sub
+                run["run_id"],
+                thread_id=run["thread_id"],
+                stream_mode=await sub,
+                cancel_on_disconnect=on_disconnect == "cancel",
             )
         ) as stream:
             async for mode, chunk, _ in stream:
@@ -248,6 +252,7 @@ async def wait_run(request: ApiRequest):
 async def wait_run_stateless(request: ApiRequest):
     """Create a stateless run, wait for the output."""
     payload = await request.json(RunCreateStateless)
+    on_disconnect = payload.get("on_disconnect", "continue")
     run_id = uuid6()
     sub = asyncio.create_task(Runs.Stream.subscribe(run_id))
 
@@ -277,6 +282,7 @@ async def wait_run_stateless(request: ApiRequest):
                 thread_id=run["thread_id"],
                 stream_mode=await sub,
                 ignore_404=True,
+                cancel_on_disconnect=on_disconnect == "cancel",
             )
         ) as stream:
             async for mode, chunk, _ in stream:

{langgraph_api-0.2.83 → langgraph_api-0.2.86}/langgraph_api/auth/langsmith/backend.py

@@ -14,6 +14,7 @@ from langgraph_api.config import (
     LANGSMITH_AUTH_VERIFY_TENANT_ID,
     LANGSMITH_TENANT_ID,
 )
+from langgraph_api.utils.cache import LRUCache
 
 
 class AuthDict(TypedDict):
@@ -23,7 +24,22 @@ class AuthDict(TypedDict):
     user_email: NotRequired[str]
 
 
+class AuthCacheEntry(TypedDict):
+    credentials: AuthCredentials
+    user: StudioUser
+
+
 class LangsmithAuthBackend(AuthenticationBackend):
+    def __init__(self):
+        self._cache = LRUCache[AuthCacheEntry](max_size=1000, ttl=60)
+
+    def _get_cache_key(self, headers):
+        """Generate cache key from authentication headers"""
+        relevant_headers = tuple(
+            (name, value) for name, value in headers if value is not None
+        )
+        return str(hash(relevant_headers))
+
     async def authenticate(
         self, conn: HTTPConnection
     ) -> tuple[AuthCredentials, BaseUser] | None:
@@ -37,6 +53,12 @@ class LangsmithAuthBackend(AuthenticationBackend):
         ]
         if not any(h[1] for h in headers):
             raise AuthenticationError("Missing authentication headers")
+
+        # Check cache first
+        cache_key = self._get_cache_key(headers)
+        if cached_entry := self._cache.get(cache_key):
+            return cached_entry["credentials"], cached_entry["user"]
+
         async with auth_client() as auth:
             if not LANGSMITH_AUTH_VERIFY_TENANT_ID and not conn.headers.get(
                 "x-api-key"
@@ -66,6 +88,10 @@ class LangsmithAuthBackend(AuthenticationBackend):
                 if auth_dict["tenant_id"] != LANGSMITH_TENANT_ID:
                     raise AuthenticationError("Invalid tenant ID")
 
-        return AuthCredentials(["authenticated"]), StudioUser(
-            auth_dict.get("user_id"), is_authenticated=True
-        )
+        credentials = AuthCredentials(["authenticated"])
+        user = StudioUser(auth_dict.get("user_id"), is_authenticated=True)
+
+        # Cache the result
+        self._cache.set(cache_key, AuthCacheEntry(credentials=credentials, user=user))
+
+        return credentials, user

{langgraph_api-0.2.83 → langgraph_api-0.2.86}/langgraph_api/config.py

@@ -173,7 +173,7 @@ LANGGRAPH_AES_KEY = env("LANGGRAPH_AES_KEY", default=None, cast=_get_encryption_
 # redis
 REDIS_URI = env("REDIS_URI", cast=str)
 REDIS_CLUSTER = env("REDIS_CLUSTER", cast=bool, default=False)
-REDIS_MAX_CONNECTIONS = env("REDIS_MAX_CONNECTIONS", cast=int, default=500)
+REDIS_MAX_CONNECTIONS = env("REDIS_MAX_CONNECTIONS", cast=int, default=2000)
 REDIS_CONNECT_TIMEOUT = env("REDIS_CONNECT_TIMEOUT", cast=float, default=10.0)
 REDIS_MAX_IDLE_TIME = env("REDIS_MAX_IDLE_TIME", cast=float, default=120.0)
 REDIS_KEY_PREFIX = env("REDIS_KEY_PREFIX", cast=str, default="")

{langgraph_api-0.2.83 → langgraph_api-0.2.86}/langgraph_api/http.py

@@ -120,9 +120,9 @@ def is_retriable_error(exception: Exception) -> bool:
         return True
     # Seems to just apply to HttpStatusError but doesn't hurt to check all
     if isinstance(exception, httpx.HTTPError):
-        return (
-            getattr(exception, "response", None) is not None
-            and exception.response.status_code >= 500
+        return getattr(exception, "response", None) is not None and (
+            exception.response.status_code >= 500
+            or exception.response.status_code == 429
         )
     return False
 

langgraph_api-0.2.86/langgraph_api/utils/cache.py

@@ -0,0 +1,58 @@
+import asyncio
+import time
+from collections import OrderedDict
+from typing import Generic, TypeVar
+
+T = TypeVar("T")
+
+
+class LRUCache(Generic[T]):
+    """LRU cache with TTL support."""
+
+    def __init__(self, max_size: int = 1000, ttl: float = 60):
+        self._cache: OrderedDict[str, tuple[T, float]] = OrderedDict()
+        self._max_size = max_size if max_size > 0 else 1000
+        self._ttl = ttl
+
+    def _get_time(self) -> float:
+        """Get current time, using loop.time() if available for better performance."""
+        try:
+            return asyncio.get_event_loop().time()
+        except RuntimeError:
+            return time.monotonic()
+
+    def get(self, key: str) -> T | None:
+        """Get item from cache, returning None if expired or not found."""
+        if key not in self._cache:
+            return None
+
+        value, timestamp = self._cache[key]
+        if self._get_time() - timestamp >= self._ttl:
+            # Expired, remove and return None
+            del self._cache[key]
+            return None
+
+        # Move to end (most recently used)
+        self._cache.move_to_end(key)
+        return value
+
+    def set(self, key: str, value: T) -> None:
+        """Set item in cache, evicting old entries if needed."""
+        # Remove if already exists (to update timestamp)
+        if key in self._cache:
+            del self._cache[key]
+
+        # Evict oldest entries if needed
+        while len(self._cache) >= self._max_size:
+            self._cache.popitem(last=False)  # Remove oldest (FIFO)
+
+        # Add new entry
+        self._cache[key] = (value, self._get_time())
+
+    def size(self) -> int:
+        """Return current cache size."""
+        return len(self._cache)
+
+    def clear(self) -> None:
+        """Clear all entries from cache."""
+        self._cache.clear()

{langgraph_api-0.2.83 → langgraph_api-0.2.86}/langgraph_api/worker.py

@@ -307,23 +307,9 @@ async def worker(
                     conn, run["thread_id"], run_id, status, checkpoint, exception
                 )
 
-            # delete or set status of thread
-            if not isinstance(exception, ALL_RETRIABLE_EXCEPTIONS):
-                if temporary:
-                    await Threads.delete(conn, run["thread_id"])
-                else:
-                    try:
-                        await Threads.set_status(
-                            conn, run["thread_id"], checkpoint, exception
-                        )
-                    except HTTPException as e:
-                        if e.status_code == 404:
-                            await logger.ainfo(
-                                "Ignoring set_status error for missing thread",
-                                exc=str(e),
-                            )
-                        else:
-                            raise
+            # delete thread if it's temporary and we don't want to retry
+            if temporary and not isinstance(exception, ALL_RETRIABLE_EXCEPTIONS):
+                await Threads.delete(conn, run["thread_id"])
 
         if isinstance(exception, ALL_RETRIABLE_EXCEPTIONS):
             await logger.awarning("RETRYING", exc_info=exception)

{langgraph_api-0.2.83 → langgraph_api-0.2.86}/langgraph_license/validation.py

@@ -1,5 +1,9 @@
 """Noop license middleware"""
 
+import structlog
+
+logger = structlog.stdlib.get_logger(__name__)
+
 
 async def get_license_status() -> bool:
     """Always return true"""
@@ -17,6 +21,7 @@ async def check_license_periodically(_: int = 60):
     If the license ever fails, you could decide to log,
     raise an exception, or attempt a graceful shutdown.
     """
-    raise NotImplementedError(
+    await logger.ainfo(
         "This is a noop license middleware. No license check is performed."
     )
+    return None