langgraph-api 0.2.66__tar.gz → 0.2.68__tar.gz

{langgraph_api-0.2.66 → langgraph_api-0.2.68}/Makefile

@@ -55,7 +55,7 @@ start:
 	LANGGRAPH_AES_KEY='$(LANGGRAPH_AES_KEY)' \
 	N_JOBS_PER_WORKER=2 \
 	LANGGRAPH_CONFIG='{"agent": {"configurable": {"model_name": "openai"}}}' \
-	LANGSERVE_GRAPHS='{"agent": "./tests/graphs/agent.py:graph", "single_node": "./tests/graphs/single_node.py:graph", "other": "./tests/graphs/other.py:make_graph", "weather": "./tests/graphs/weather.py:mk_weather_graph", "searchy": "./tests/graphs/searchy.py:graph", "agent_simple": "./tests/graphs/agent_simple.py:graph"}' \
+	LANGSERVE_GRAPHS='{"agent": "./tests/graphs/agent.py:graph", "single_node": "./tests/graphs/single_node.py:graph", "benchmark": "./tests/graphs/benchmark.py:graph", "other": "./tests/graphs/other.py:make_graph", "weather": "./tests/graphs/weather.py:mk_weather_graph", "searchy": "./tests/graphs/searchy.py:graph", "agent_simple": "./tests/graphs/agent_simple.py:graph"}' \
 	LANGGRAPH_STORE='$(STORE_CONFIG)' \
 	LANGGRAPH_CONFIG='{"agent": {"configurable": {"model_name": "openai"}}}' \
 	LANGSMITH_LANGGRAPH_API_VARIANT=test \

{langgraph_api-0.2.66 → langgraph_api-0.2.68}/PKG-INFO

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

langgraph_api-0.2.68/benchmark/.gitignore

@@ -0,0 +1,3 @@
+# K6 summary and results files
+results_*.json
+summary_*.json

langgraph_api-0.2.68/benchmark/Makefile

@@ -0,0 +1,6 @@
+# Benchmark commands
+benchmark-burst:
+	k6 run burst.js
+
+benchmark-clean:
+	rm -f results_*.json summary_*.json

langgraph_api-0.2.68/benchmark/README.md

@@ -0,0 +1,43 @@
+# 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
+
+1. Burst - Kick off a burst of /run/wait requests.
+
+## Running Tests Locally
+
+### 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`
+
+### Basic Usage
+
+```bash
+# Run burst test with default burst size (50)
+make benchmark-burst
+
+# Run burst test with custom burst size
+BURST_SIZE=500 make benchmark-burst
+
+# Run burst test against a deployment
+BASE_URL=https://jdr-debug-31ac2c83eef557309f21c1e98d822025.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.68/benchmark/burst.js

@@ -0,0 +1,195 @@
+import http from 'k6/http';
+import { check } from 'k6';
+import { Counter, Trend, Rate } from 'k6/metrics';
+import exec from 'k6/execution';
+
+// 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');
+const burstSuccessRate = new Rate('burst_success_rate');
+
+// URL of your LangGraph server
+const BASE_URL = __ENV.BASE_URL || 'http://localhost:9123';
+const BURST_SIZE = parseInt(__ENV.BURST_SIZE || '50');
+
+// Burst testing configuration
+export let options = {
+  scenarios: {
+    burst_test: {
+      executor: 'shared-iterations',  // All VUs share the total iterations
+      vus: BURST_SIZE,  // Number of concurrent requests in the burst
+      iterations: BURST_SIZE,  // Each VU does one request per burst
+      maxDuration: '10s',  // Time limit for each burst
+    },
+  },
+  thresholds: {
+    'run_duration': ['p(95)<3500'],
+    'burst_success_rate': ['rate>0.99'],
+  },
+};
+
+// Main test function - executes during the burst
+export default function() {
+  const startTime = new Date().getTime();
+
+  // Create a unique identifier for each VU
+  const burstId = __ENV.BURST_ID || '1';
+
+  try {
+    // Log burst start
+    console.log(`[Burst ${burstId}] VU ${exec.vu.idInInstance} starting request`);
+
+    // Prepare the request payload
+    const headers = { 'Content-Type': 'application/json' };
+
+    // Create a payload with the LangGraph agent configuration
+    const payload = JSON.stringify({
+      assistant_id: "benchmark",
+      config: { delay: 0.1 },
+      input: {delay: 0.1, random_value: 'hello'},
+    });
+
+    // Make a single request to the wait endpoint
+    const response = http.post(`${BASE_URL}/runs/wait`, payload, {
+      headers,
+      timeout: '35s'
+    });
+
+    // Check the response
+    const success = check(response, {
+      'Run completed successfully': (r) => r.status === 200,
+      'Response contains data': (r) => r.body.length > 0,
+    });
+
+    if (success) {
+      // Record success metrics
+      const duration = new Date().getTime() - startTime;
+      runDuration.add(duration);
+      successfulRuns.add(1);
+      burstSuccessRate.add(1);  // 1 = success
+
+      // Optional: Log successful run details
+      console.log(`[Burst ${burstId}] VU ${exec.vu.idInInstance} completed in ${duration/1000}s`);
+    } else {
+      // Handle failure
+      failedRuns.add(1);
+      burstSuccessRate.add(0);  // 0 = failure
+
+      // Classify error based on status code or response
+      if (response.status >= 500) {
+        serverErrors.add(1);
+        console.log(`[Burst ${burstId}] VU ${exec.vu.idInInstance} server error: ${response.status}`);
+      } else if (response.status === 408 || response.error === 'timeout') {
+        timeoutErrors.add(1);
+        console.log(`[Burst ${burstId}] VU ${exec.vu.idInInstance} timeout error: ${response.error}`);
+      } else {
+        otherErrors.add(1);
+        console.log(`response: ${JSON.stringify(response)}`);
+        console.log(`[Burst ${burstId}] VU ${exec.vu.idInInstance} other error: Status ${response.status}, ${response.error}`);
+      }
+    }
+
+  } catch (error) {
+    // Handle exceptions (network errors, etc.)
+    failedRuns.add(1);
+    burstSuccessRate.add(0);  // 0 = failure
+
+    if (error.message.includes('timeout')) {
+      timeoutErrors.add(1);
+      console.log(`[Burst ${burstId}] VU ${exec.vu.idInInstance} timeout error: ${error.message}`);
+    } else if (error.message.includes('connection') || error.message.includes('network')) {
+      connectionErrors.add(1);
+      console.log(`[Burst ${burstId}] VU ${exec.vu.idInInstance} connection error: ${error.message}`);
+    } else {
+      otherErrors.add(1);
+      console.log(`[Burst ${burstId}] VU ${exec.vu.idInInstance} unexpected error: ${error.message}`);
+    }
+  }
+}
+
+// Setup function
+export function setup() {
+  console.log(`Starting burst benchmark`);
+  console.log(`Running on pod: ${__ENV.POD_NAME || 'local'}`);
+  console.log(`Burst size: ${BURST_SIZE}`);
+
+  return { startTime: new Date().toISOString() };
+}
+
+// Handle summary
+export function handleSummary(data) {
+  // Helper function to safely access nested properties
+  const safeGet = (obj, path, defaultValue) => {
+    try {
+      const parts = path.split('.');
+      let result = obj;
+
+      for (const part of parts) {
+        if (result === undefined || result === null) return defaultValue;
+        result = result[part];
+      }
+
+      return result === undefined || result === null ? defaultValue : result;
+    } catch (e) {
+      return defaultValue;
+    }
+  };
+
+  // Calculate average burst success rate
+  const burstRate = safeGet(data, 'metrics.burst_success_rate.values.rate', 0) * 100;
+
+  // Create a condensed summary with key metrics
+  const summary = {
+    timestamp: new Date().toISOString(),
+    podName: __ENV.POD_NAME || 'local',
+    burstSettings: {
+      burstSize: BURST_SIZE,
+    },
+    metrics: {
+      totalRuns: safeGet(data, 'metrics.iterations.values.count', 0),
+      successfulRuns: safeGet(data, 'metrics.successful_runs.values.count', 0),
+      failedRuns: safeGet(data, 'metrics.failed_runs.values.count', 0),
+      burstSuccessRate: burstRate.toFixed(2) + '%',
+      avgDuration: safeGet(data, 'metrics.run_duration.values.avg', 0) / 1000,
+      p95Duration: safeGet(data, 'metrics.run_duration.values.p(95)', 0) / 1000,
+      errors: {
+        timeout: safeGet(data, 'metrics.timeout_errors.values.count', 0),
+        connection: safeGet(data, 'metrics.connection_errors.values.count', 0),
+        server: safeGet(data, 'metrics.server_errors.values.count', 0),
+        other: safeGet(data, 'metrics.other_errors.values.count', 0)
+      }
+    },
+    raw: {
+      http_reqs: safeGet(data, 'metrics.http_reqs.values.count', 0),
+      http_req_failed: safeGet(data, 'metrics.http_req_failed.values.rate', 0),
+      http_req_duration: {
+        avg: safeGet(data, 'metrics.http_req_duration.values.avg', 0),
+        min: safeGet(data, 'metrics.http_req_duration.values.min', 0),
+        med: safeGet(data, 'metrics.http_req_duration.values.med', 0),
+        max: safeGet(data, 'metrics.http_req_duration.values.max', 0),
+        p90: safeGet(data, 'metrics.http_req_duration.values.p(90)', 0),
+        p95: safeGet(data, 'metrics.http_req_duration.values.p(95)', 0),
+        p99: safeGet(data, 'metrics.http_req_duration.values.p(99)', 0)
+      }
+    }
+  };
+
+  // Print the summary as JSON to the logs
+  console.log(`====== BURST TEST SUMMARY ======`);
+  console.log(`SUMMARY_JSON_START ${JSON.stringify(summary)} SUMMARY_JSON_END`);
+
+  // Generate output files
+  const burstStr = `burst${BURST_SIZE}`;
+  const timestamp = new Date().toISOString().replace(/:/g, '-').replace(/\..+/, '');
+
+  return {
+    [`results_${burstStr}_${timestamp}.json`]: JSON.stringify(data, null, 2),
+    [`summary_${burstStr}_${timestamp}.json`]: JSON.stringify(summary, null, 2),
+    stdout: JSON.stringify(summary, null, 2)  // Also print summary to console
+  };
+}

langgraph_api-0.2.68/langgraph_api/__init__.py

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

{langgraph_api-0.2.66 → langgraph_api-0.2.68}/langgraph_api/cli.py

@@ -114,6 +114,46 @@ class AuthConfig(TypedDict, total=False):
     """
 
 
+def _check_newer_version(pkg: str, timeout: float = 0.2) -> None:
+    """Log a notice if PyPI reports a newer version."""
+    import importlib.metadata as md
+    import json
+    import urllib.request
+
+    from packaging.version import Version
+
+    thread_logger = logging.getLogger("check_version")
+    if not thread_logger.handlers:
+        handler = logging.StreamHandler()
+        handler.setFormatter(logging.Formatter("%(message)s"))
+        thread_logger.addHandler(handler)
+
+    try:
+        current = Version(md.version(pkg))
+        with urllib.request.urlopen(
+            f"https://pypi.org/pypi/{pkg}/json", timeout=timeout
+        ) as resp:
+            latest_str = json.load(resp)["info"]["version"]
+        latest = Version(latest_str)
+        if latest > current:
+            thread_logger.info(
+                "🔔  A newer version of %s is available: %s → %s (pip install -U %s)",
+                pkg,
+                current,
+                latest,
+                pkg,
+            )
+
+    except Exception:
+        pass
+
+    except RuntimeError:
+        thread_logger.info(
+            f"Failed to check for newer version of {pkg}."
+            " To disable version checks, set LANGGRAPH_NO_VERSION_CHECK=true"
+        )
+
+
 def run_server(
     host: str = "127.0.0.1",
     port: int = 2024,
@@ -312,6 +352,11 @@ For production use, please use LangGraph Cloud.
         logger.info(welcome)
         if open_browser:
             threading.Thread(target=_open_browser, daemon=True).start()
+        nvc = os.getenv("LANGGRAPH_NO_VERSION_CHECK")
+        if nvc is None or nvc.lower() not in ("true", "1"):
+            threading.Thread(
+                target=_check_newer_version, args=("langgraph-api",), daemon=True
+            ).start()
         supported_kwargs = {
             k: v
             for k, v in kwargs.items()

langgraph_api-0.2.66/langgraph_api/__init__.py

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