langgraph-api 0.2.130__tar.gz → 0.2.134__tar.gz

{langgraph_api-0.2.130 → langgraph_api-0.2.134}/Makefile

@@ -5,6 +5,7 @@
 lint:
 	uv run ruff check .
 	uv run ruff format . --diff
+	uvx ty check --exclude "**/pb/**" --exclude "**/*_test.py" --exclude "**/test_*.py" --exclude "**/tests/**" --exclude "venv/**" --exclude ".venv/**" --exclude "build/**" --exclude "dist/**" .
 
 format:
 	uv run ruff check --fix .
@@ -40,6 +41,8 @@ test-watch-oss:
 
 test: test-license-oss
 test-watch: test-watch-oss
+unit-test:
+	DATABASE_URI="test" REDIS_URI="test" uv run pytest tests/unit_tests
 
 test-auth:
 	LANGGRAPH_RUNTIME_EDITION=inmem LANGGRAPH_AUTH='{"path": "./tests/graphs/fastapi_jwt_auth.py:get_current_active_user"}' REDIS_URI=_FAKE DATABASE_URI=:memory: MIGRATIONS_PATH=__inmem__ uv run pytest -v $(AUTH_TEST)
@@ -113,4 +116,4 @@ start-auth-fastapi-jwt:
 VERSION_KIND ?= patch
 
 bump-version:
-	uv run --with hatch hatch version $(VERSION_KIND)
+	uv run --with hatch hatch version $(VERSION_KIND)

{langgraph_api-0.2.130 → langgraph_api-0.2.134}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.2.130
+Version: 0.2.134
 Author-email: Nuno Campos <nuno@langchain.dev>, Will Fu-Hinthorn <will@langchain.dev>
 License: Elastic-2.0
 License-File: LICENSE
@@ -11,7 +11,7 @@ Requires-Dist: httpx>=0.25.0
 Requires-Dist: jsonschema-rs<0.30,>=0.20.0
 Requires-Dist: langchain-core>=0.3.64
 Requires-Dist: langgraph-checkpoint>=2.0.23
-Requires-Dist: langgraph-runtime-inmem<0.7,>=0.6.13
+Requires-Dist: langgraph-runtime-inmem<0.9.0,>=0.8.0
 Requires-Dist: langgraph-sdk>=0.2.0
 Requires-Dist: langgraph>=0.4.0
 Requires-Dist: langsmith>=0.3.45

langgraph_api-0.2.134/benchmark/.gitignore

@@ -0,0 +1,10 @@
+# K6 summary and results files
+results_*.json
+summary_*.json
+raw_data_*.json
+
+# Generated chart files
+*_chart_*.png
+
+# Node.js dependencies
+node_modules/

langgraph_api-0.2.134/benchmark/Makefile

@@ -0,0 +1,16 @@
+# Benchmark commands
+benchmark-burst:
+	k6 run burst.js
+
+benchmark-ramp:
+	k6 run --out json=raw_data_$(shell date +%Y-%m-%dT%H-%M-%S).json ramp.js
+
+benchmark-charts:
+	npm install
+	node graphs.js $(shell ls -t raw_data_*.json | head -1) true
+
+benchmark-clean:
+	rm -f results_*.json summary_*.json raw_data_*.json *_chart_*.png
+
+benchmark-clean-charts:
+	rm -f *_chart_*.png

{langgraph_api-0.2.130 → langgraph_api-0.2.134}/benchmark/README.md

@@ -12,8 +12,8 @@ There are two modes of testing available:
         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
+        LOAD_SIZE - How much traffic to ramp up over a 60s period. Default: 500
+        LEVELS - The number of times to ramp up. Default: 2
         PLATEAU_DURATION - How long to sustain the max level of traffic in seconds. Default: 300
 
 ### Agent
@@ -65,6 +65,8 @@ make benchmark-clean
 
 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.
 
+Charts can be created from the run locally using the `make benchmark-charts` command.
+
 ## Resources
 
 - [K6 Documentation](https://k6.io/docs/)

{langgraph_api-0.2.130 → langgraph_api-0.2.134}/benchmark/burst.js

@@ -139,7 +139,8 @@ export default function() {
 export function setup() {
   console.log(`Starting burst benchmark`);
   console.log(`Running on pod: ${__ENV.POD_NAME || 'local'}`);
-  console.log(`Burst size: ${BURST_SIZE}`);
+  console.log(`Running with the following burst config: burst size ${BURST_SIZE}`);
+  console.log(`Running with the following agent config: data size ${DATA_SIZE}, delay ${DELAY}, expand ${EXPAND}, mode ${MODE}`);
 
   return { startTime: new Date().toISOString() };
 }

langgraph_api-0.2.134/benchmark/graphs.js

@@ -0,0 +1,236 @@
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const QuickChart = require('quickchart-js');
+const { plot } = require('nodeplotlib');
+
+// Function to save chart using Quickchart
+async function saveChartWithQuickchart(chartData, chartLayout, filename) {
+  const chart = new QuickChart();
+
+  chart.setWidth(800);
+  chart.setHeight(500);
+  chart.setFormat('png');
+
+  const config = {
+    type: 'line',
+    data: {
+      labels: chartData[0].x,
+      datasets: chartData.map(metric => {
+        return {
+            label: metric.name,
+            data: metric.y
+        }
+      })
+    }
+  };
+
+  chart.setConfig(config);
+
+  try {
+    const imageBuffer = await chart.toBinary();
+    fs.writeFileSync(filename, imageBuffer);
+    console.log(`Chart saved to ${filename}`);
+  } catch (error) {
+    console.error(`Error saving chart to ${filename}:`, error.message);
+  }
+}
+
+/**
+ * Function to generate charts from benchmark results
+ * 
+ * Graphs that we generate:
+ * - VU scaling over time
+ * - Requests over time, broken into success and failure by reason
+ * - Average run duration over time
+ * 
+ * Useful but currently in deployment dashboard:
+ * - Connection use over time (postgres, redis)
+ * - IOPS over time (postgres, redis)
+ * - Workers in use over time
+ * 
+ * Dashboard: https://smith.langchain.com/o/ebbaf2eb-769b-4505-aca2-d11de10372a4/host/deployments/a23f03ff-6d4d-4efd-8149-bb5a7f3b95cf?tab=2&paginationModel=%7B%22pageIndex%22%3A0%2C%22pageSize%22%3A10%7D#
+ */
+async function generateCharts(rawDataFile, displayInBrowser = false) {
+    console.log("Generating charts for", rawDataFile);
+    const aggregatedData = {};
+
+    // Read the results and summary files
+    const fileStream = fs.createReadStream(rawDataFile, 'utf8');
+    const rl = readline.createInterface({
+        input: fileStream,
+        crlfDelay: Infinity
+    });
+
+    for await (const line of rl) {
+        const entry = JSON.parse(line);
+
+        // Always written before the first point for that metric
+        if (entry.type === 'Metric') {
+            const metricName = entry.metric;
+            aggregatedData[metricName] = {};
+        } else if (entry.type === 'Point') {
+            const metricName = entry.metric;
+            const metricValue = entry.data.value;
+            const timestamp = Date.parse(entry.data.time);
+
+            // Round timestamp to 10-second intervals
+            const roundedTimestamp = Math.floor(timestamp / 10000) * 10000;
+
+            if (!aggregatedData[metricName][roundedTimestamp]) {
+                aggregatedData[metricName][roundedTimestamp] = [];
+            }
+            aggregatedData[metricName][roundedTimestamp].push(metricValue);
+        } else {
+            throw new Error(`Unexpected row type: ${entry.type}`);
+        }
+    }
+
+    // Convert aggregated data to final format with averages
+    const finalData = {};
+    for (const [metricName, timestampBuckets] of Object.entries(aggregatedData)) {
+        finalData[metricName] = [];
+        for (const [timestamp, values] of Object.entries(timestampBuckets)) {
+            const average = values.reduce((sum, val) => sum + val, 0) / values.length;
+            const max = Math.max(...values);
+            finalData[metricName].push({ 
+                timestamp: timestamp,
+                average: average,
+                max: max,
+                count: values.length
+            });
+        }
+        // Sort by timestamp
+        finalData[metricName].sort((a, b) => a.timestamp - b.timestamp);
+    }
+
+    // Create the charts
+    // We always get a http_reqs metric as one of the first
+    const firstTimestamp = finalData['http_reqs'][0].timestamp;
+
+    // Failed requests won't always be present
+    const data = [
+        {
+            x: finalData['http_reqs'].map(d => (d.timestamp - firstTimestamp) / 1000),
+            y: finalData['http_reqs'].map(d => d.count),
+            type: 'scatter',
+            mode: 'lines',
+            name: 'Total Requests',
+        },
+        {
+            x: finalData['successful_runs'].map(d => (d.timestamp - firstTimestamp) / 1000),
+            y: finalData['successful_runs'].map(d => d.count),
+            type: 'scatter',
+            mode: 'lines',
+            name: 'Success Rate',
+        }
+    ]
+    if (finalData['failed_runs']) {
+        data.push({
+            x: finalData['failed_runs'].map(d => (d.timestamp - firstTimestamp) / 1000),
+            y: finalData['failed_runs'].map(d => d.count),
+            type: 'scatter',
+            mode: 'lines',
+            name: 'Failed Requests',
+        })
+    }
+
+    const requestsChart = {
+        data,
+        layout: {
+        title: {
+            text: 'Success Rate Over Time',
+        },
+        xaxis: { 
+            title: 'Time (10 second intervals)',
+        },
+        yaxis: { 
+            title: 'Call Counts',
+        }
+        }
+    };
+
+    const runDurationChart = {
+        data: [
+        {
+            x: finalData['run_duration'].map(d => (d.timestamp - firstTimestamp) / 1000),
+            y: finalData['run_duration'].map(d => d.average),
+            type: 'scatter',
+            mode: 'lines',
+            name: 'Run Duration',
+        }
+        ],
+        layout: {
+        title: {
+            text: 'Run Duration Over Time',
+        },
+        xaxis: { 
+            title: 'Time (10 second intervals)',
+        },
+        yaxis: { 
+            title: 'Run Duration (ms)',
+        },
+        }
+    }
+
+    const vusChart = {
+        data: [
+        {
+            x: finalData['vus'].map(d => (d.timestamp - firstTimestamp) / 1000),
+            y: finalData['vus'].map(d => d.max),
+            type: 'scatter',
+            mode: 'lines',
+            name: 'Concurrent Virtual Users',
+        }
+        ],
+        layout: {
+        title: {
+            text: 'Concurrent Virtual Users over Time',
+        },
+        xaxis: { 
+            title: 'Time (10 second intervals)',
+        },
+        yaxis: { 
+            title: 'VUs (max)',
+        },
+        }
+    }
+
+    // Always save charts as images using Quickchart
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const requestsImagePath = path.join(__dirname, `requests_chart_${timestamp}.png`);
+    const runDurationImagePath = path.join(__dirname, `run_duration_chart_${timestamp}.png`);
+    const vusImagePath = path.join(__dirname, `vus_chart_${timestamp}.png`);
+
+    // Save charts using Quickchart
+    await saveChartWithQuickchart(requestsChart.data, requestsChart.layout, requestsImagePath);
+    await saveChartWithQuickchart(runDurationChart.data, runDurationChart.layout, runDurationImagePath);
+    await saveChartWithQuickchart(vusChart.data, vusChart.layout, vusImagePath);
+
+    // Display in CLI if requested
+    if (displayInBrowser) {
+        plot(requestsChart.data, requestsChart.layout);
+        plot(runDurationChart.data, runDurationChart.layout);
+        plot(vusChart.data, vusChart.layout);
+    }
+    
+    console.log(`Charts generated: ${vusImagePath}, ${requestsImagePath}, ${runDurationImagePath}`);
+}
+
+// CLI usage
+if (require.main === module) {
+  const [,, rawDataFile, displayInBrowser] = process.argv;
+  
+  if (!rawDataFile) {
+    console.error('Usage: node graphs.js <raw-data-file>');
+    process.exit(1);
+  }
+  
+  generateCharts(rawDataFile, displayInBrowser)
+    .catch(error => {
+      console.error('Failed to generate charts:', error);
+      process.exit(1);
+    });
+}
+
+module.exports = { generateCharts };

langgraph_api-0.2.134/benchmark/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "benchmark-charts",
+  "version": "1.0.0",
+  "description": "Chart generation for K6 benchmark results",
+  "main": "graphs.js",
+  "scripts": {
+    "generate-charts": "node graphs.js"
+  },
+  "dependencies": {
+    "nodeplotlib": "^1.0.4",
+    "quickchart-js": "^3.1.3"
+  },
+  "devDependencies": {},
+  "engines": {
+    "node": ">=14.0.0"
+  }
+} 

{langgraph_api-0.2.130 → langgraph_api-0.2.134}/benchmark/ramp.js

@@ -18,9 +18,10 @@ const BASE_URL = __ENV.BASE_URL || 'http://localhost:9123';
 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 LOAD_SIZE = parseInt(__ENV.LOAD_SIZE || '500');
+const LEVELS = parseInt(__ENV.LEVELS || '2');
 const PLATEAU_DURATION = parseInt(__ENV.PLATEAU_DURATION || '300');
+const STATEFUL = __ENV.STATEFUL === 'true';
 
 // Params for the agent
 const DATA_SIZE = parseInt(__ENV.DATA_SIZE || '1000');
@@ -33,7 +34,7 @@ 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
+stages.push({ duration: '60s', target: 0 }); // Ramp down
 
 // Test configuration
 export let options = {
@@ -46,9 +47,10 @@ export let options = {
     },
   },
   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%
+    // These are the first set of goals I'd like to hit. To get the job just working and ramp on main, leaving them off for now.
+    // 'run_duration': ['p(95)<10000'],  // 95% of runs should complete within 10s
+    // 'successful_runs': ['count>100000'],  // At least 100,000 successful runs
+    // 'http_req_failed': ['rate<0.05'],   // Error rate should be less than 5%
   },
 };
 
@@ -75,10 +77,21 @@ export default function() {
         config: {
           recursion_limit: EXPAND + 2,
         },
+    });
+
+    // If the request is stateful, create a thread first and use it in the url
+    let url = `${BASE_URL}/runs/wait`;
+    if (STATEFUL) {
+      const thread = http.post(`${BASE_URL}/threads`, payload, {
+        headers,
+        timeout: '120s'  // k6 request timeout slightly longer than the server timeout
       });
+      const threadId = thread.json().thread_id;
+      url = `${BASE_URL}/threads/${threadId}/runs/wait`;
+    }
 
     // Make a single request to the wait endpoint
-    const response = http.post(`${BASE_URL}/runs/wait`, payload, {
+    const response = http.post(url, payload, {
       headers,
       timeout: '120s'  // k6 request timeout slightly longer than the server timeout
     });
@@ -141,9 +154,10 @@ export default 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}`);
+  console.log(`Running with the following ramp config: load size ${LOAD_SIZE}, levels ${LEVELS}, plateau duration ${PLATEAU_DURATION}, stateful ${STATEFUL}`);
+  console.log(`Running with the following agent config: data size ${DATA_SIZE}, delay ${DELAY}, expand ${EXPAND}, mode ${MODE}`);
 
-  return { startTime: new Date().toISOString() };
+  return { startTime: new Date().toISOString().replace(/:/g, '-').replace(/\..+/, '') };
 }
 
 // Handle summary
@@ -152,13 +166,14 @@ export function handleSummary(data) {
 
   // Create summary information with aggregated metrics
   const summary = {
-    timestamp: timestamp,
+    startTimestamp: data.setup_data.startTime,
+    endTimestamp: timestamp,
     metrics: {
-      totalRuns: data.metrics.successful_runs.values.count + data.metrics.failed_runs.values.count,
+      totalRuns: data.metrics.successful_runs.values.count + (data.metrics.failed_runs?.values?.count || 0),
       successfulRuns: data.metrics.successful_runs.values.count,
-      failedRuns: data.metrics.failed_runs.values.count,
+      failedRuns: data.metrics.failed_runs?.values?.count || 0,
       successRate: data.metrics.successful_runs.values.count /
-                  (data.metrics.successful_runs.values.count + data.metrics.failed_runs.values.count) * 100,
+                  (data.metrics.successful_runs.values.count + (data.metrics.failed_runs?.values?.count || 0)) * 100,
       averageDuration: data.metrics.run_duration.values.avg / 1000,  // in seconds
       p95Duration: data.metrics.run_duration.values["p(95)"] / 1000, // in seconds
       errors: {

langgraph_api-0.2.134/langgraph_api/__init__.py

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

{langgraph_api-0.2.130 → langgraph_api-0.2.134}/langgraph_api/api/assistants.py

@@ -16,9 +16,16 @@ from langgraph_api.feature_flags import USE_RUNTIME_CONTEXT_API
 from langgraph_api.graph import get_assistant_id, get_graph
 from langgraph_api.js.base import BaseRemotePregel
 from langgraph_api.route import ApiRequest, ApiResponse, ApiRoute
+from langgraph_api.schema import ASSISTANT_FIELDS
 from langgraph_api.serde import ajson_loads
-from langgraph_api.utils import fetchone, get_pagination_headers, validate_uuid
+from langgraph_api.utils import (
+    fetchone,
+    get_pagination_headers,
+    validate_select_columns,
+    validate_uuid,
+)
 from langgraph_api.validation import (
+    AssistantCountRequest,
     AssistantCreate,
     AssistantPatch,
     AssistantSearchRequest,
@@ -61,7 +68,8 @@ def _get_configurable_jsonschema(graph: Pregel) -> dict:
     in favor of graph.get_context_jsonschema().
     """
     # Otherwise, use the config_schema method.
-    config_schema = graph.config_schema()
+    # TODO: Remove this when we no longer support langgraph < 0.6
+    config_schema = graph.config_schema()  # type: ignore[deprecated]
     model_fields = getattr(config_schema, "model_fields", None) or getattr(
         config_schema, "__fields__", None
     )
@@ -87,11 +95,11 @@ def _state_jsonschema(graph: Pregel) -> dict | None:
     for k in graph.stream_channels_list:
         v = graph.channels[k]
         try:
-            create_model(k, __root__=(v.UpdateType, None)).schema()
+            create_model(k, __root__=(v.UpdateType, None)).model_json_schema()
             fields[k] = (v.UpdateType, None)
         except Exception:
             fields[k] = (Any, None)
-    return create_model(graph.get_name("State"), **fields).schema()
+    return create_model(graph.get_name("State"), **fields).model_json_schema()
 
 
 def _graph_schemas(graph: Pregel) -> dict:
@@ -132,7 +140,7 @@ def _graph_schemas(graph: Pregel) -> dict:
             logger.warning(
                 f"Failed to get context schema for graph {graph.name} with error: `{str(e)}`"
             )
-            context_schema = graph.config_schema()
+            context_schema = graph.config_schema()  # type: ignore[deprecated]
     else:
         context_schema = None
 
@@ -172,6 +180,7 @@ async def search_assistants(
 ) -> ApiResponse:
     """List assistants."""
     payload = await request.json(AssistantSearchRequest)
+    select = validate_select_columns(payload.get("select") or None, ASSISTANT_FIELDS)
     offset = int(payload.get("offset") or 0)
     async with connect() as conn:
         assistants_iter, next_offset = await Assistants.search(
@@ -182,6 +191,7 @@ async def search_assistants(
             offset=offset,
             sort_by=payload.get("sort_by"),
             sort_order=payload.get("sort_order"),
+            select=select,
         )
     assistants, response_headers = await get_pagination_headers(
         assistants_iter, next_offset, offset
@@ -189,6 +199,21 @@ async def search_assistants(
     return ApiResponse(assistants, headers=response_headers)
 
 
+@retry_db
+async def count_assistants(
+    request: ApiRequest,
+) -> ApiResponse:
+    """Count assistants."""
+    payload = await request.json(AssistantCountRequest)
+    async with connect() as conn:
+        count = await Assistants.count(
+            conn,
+            graph_id=payload.get("graph_id"),
+            metadata=payload.get("metadata"),
+        )
+    return ApiResponse(count)
+
+
 @retry_db
 async def get_assistant(
     request: ApiRequest,
@@ -366,7 +391,7 @@ async def patch_assistant(
 
 
 @retry_db
-async def delete_assistant(request: ApiRequest) -> ApiResponse:
+async def delete_assistant(request: ApiRequest) -> Response:
     """Delete an assistant by ID."""
     assistant_id = request.path_params["assistant_id"]
     validate_uuid(assistant_id, "Invalid assistant ID: must be a UUID")
@@ -414,6 +439,7 @@ async def set_latest_assistant_version(request: ApiRequest) -> ApiResponse:
 assistants_routes: list[BaseRoute] = [
     ApiRoute("/assistants", create_assistant, methods=["POST"]),
     ApiRoute("/assistants/search", search_assistants, methods=["POST"]),
+    ApiRoute("/assistants/count", count_assistants, methods=["POST"]),
     ApiRoute(
         "/assistants/{assistant_id}/latest",
         set_latest_assistant_version,

{langgraph_api-0.2.130 → langgraph_api-0.2.134}/langgraph_api/api/meta.py

@@ -1,3 +1,5 @@
+from typing import cast
+
 import langgraph.version
 from starlette.responses import JSONResponse, PlainTextResponse
 
@@ -43,7 +45,7 @@ async def meta_metrics(request: ApiRequest):
 
     # collect stats
     metrics = get_metrics()
-    worker_metrics = metrics["workers"]
+    worker_metrics = cast(dict[str, int], metrics["workers"])
     workers_max = worker_metrics["max"]
     workers_active = worker_metrics["active"]
     workers_available = worker_metrics["available"]

{langgraph_api-0.2.130 → langgraph_api-0.2.134}/langgraph_api/api/openapi.py

@@ -25,7 +25,7 @@ def set_custom_spec(spec: dict):
 
 
 @lru_cache(maxsize=1)
-def get_openapi_spec() -> str:
+def get_openapi_spec() -> bytes:
     # patch the graph_id enums
     graph_ids = list(GRAPHS.keys())
     for schema in (