langgraph-api 0.0.1__py3-none-any.whl

langgraph_api/validation.py

@@ -0,0 +1,141 @@
+import pathlib
+
+import jsonschema_rs
+import orjson
+
+with open(pathlib.Path(__file__).parent.parent / "openapi.json") as f:
+    openapi_str = f.read()
+
+openapi = orjson.loads(openapi_str)
+
+AssistantVersionsSearchRequest = jsonschema_rs.validator_for(
+    openapi["components"]["schemas"]["AssistantVersionsSearchRequest"]
+)
+AssistantSearchRequest = jsonschema_rs.validator_for(
+    openapi["components"]["schemas"]["AssistantSearchRequest"]
+)
+ThreadSearchRequest = jsonschema_rs.validator_for(
+    openapi["components"]["schemas"]["ThreadSearchRequest"]
+)
+AssistantCreate = jsonschema_rs.validator_for(
+    openapi["components"]["schemas"]["AssistantCreate"]
+)
+AssistantPatch = jsonschema_rs.validator_for(
+    openapi["components"]["schemas"]["AssistantPatch"]
+)
+AssistantVersionChange = jsonschema_rs.validator_for(
+    openapi["components"]["schemas"]["AssistantVersionChange"]
+)
+ThreadCreate = jsonschema_rs.validator_for(
+    openapi["components"]["schemas"]["ThreadCreate"]
+)
+ThreadPatch = jsonschema_rs.validator_for(
+    openapi["components"]["schemas"]["ThreadPatch"]
+)
+ThreadStateUpdate = jsonschema_rs.validator_for(
+    {
+        **openapi["components"]["schemas"]["ThreadStateUpdate"],
+        "components": {
+            "schemas": {
+                "CheckpointConfig": openapi["components"]["schemas"]["CheckpointConfig"]
+            }
+        },
+    }
+)
+ThreadStateCheckpointRequest = jsonschema_rs.validator_for(
+    {
+        **openapi["components"]["schemas"]["ThreadStateCheckpointRequest"],
+        "components": {
+            "schemas": {
+                "CheckpointConfig": openapi["components"]["schemas"]["CheckpointConfig"]
+            }
+        },
+    }
+)
+ThreadStateSearch = jsonschema_rs.validator_for(
+    {
+        **openapi["components"]["schemas"]["ThreadStateSearch"],
+        "components": {
+            "schemas": {
+                "CheckpointConfig": openapi["components"]["schemas"]["CheckpointConfig"]
+            }
+        },
+    }
+)
+RunCreateStateless = jsonschema_rs.validator_for(
+    {
+        **openapi["components"]["schemas"]["RunCreateStateless"],
+        "components": {
+            "schemas": {
+                "Command": openapi["components"]["schemas"]["Command"],
+                "Send": openapi["components"]["schemas"]["Send"],
+            }
+        },
+    }
+)
+RunBatchCreate = jsonschema_rs.validator_for(
+    {
+        **openapi["components"]["schemas"]["RunBatchCreate"],
+        "components": {
+            "schemas": {
+                "RunCreateStateless": openapi["components"]["schemas"][
+                    "RunCreateStateless"
+                ],
+                "Command": openapi["components"]["schemas"]["Command"],
+                "Send": openapi["components"]["schemas"]["Send"],
+            }
+        },
+    }
+)
+RunCreateStateful = jsonschema_rs.validator_for(
+    {
+        **openapi["components"]["schemas"]["RunCreateStateful"],
+        "components": {
+            "schemas": {
+                "CheckpointConfig": openapi["components"]["schemas"][
+                    "CheckpointConfig"
+                ],
+                "Command": openapi["components"]["schemas"]["Command"],
+                "Send": openapi["components"]["schemas"]["Send"],
+            }
+        },
+    }
+)
+CronCreate = jsonschema_rs.validator_for(openapi["components"]["schemas"]["CronCreate"])
+CronSearch = jsonschema_rs.validator_for(openapi["components"]["schemas"]["CronSearch"])
+
+
+# Stuff around storage/BaseStore API
+StorePutRequest = jsonschema_rs.validator_for(
+    openapi["components"]["schemas"]["StorePutRequest"]
+)
+StoreSearchRequest = jsonschema_rs.validator_for(
+    openapi["components"]["schemas"]["StoreSearchRequest"]
+)
+StoreDeleteRequest = jsonschema_rs.validator_for(
+    openapi["components"]["schemas"]["StoreDeleteRequest"]
+)
+StoreListNamespacesRequest = jsonschema_rs.validator_for(
+    openapi["components"]["schemas"]["StoreListNamespacesRequest"]
+)
+
+
+DOCS_HTML = """<!doctype html>
+<html>
+  <head>
+    <title>Scalar API Reference</title>
+    <meta charset="utf-8" />
+    <meta
+      name="viewport"
+      content="width=device-width, initial-scale=1" />
+  </head>
+  <body>
+    <script id="api-reference" data-url="/openapi.json"></script>
+    <script>
+      var configuration = {}
+      document.getElementById('api-reference').dataset.configuration =
+        JSON.stringify(configuration)
+    </script>
+    <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"></script>
+  </body>
+</html>"""

langgraph_api-0.0.1.dist-info/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-0.0.1.dist-info/METADATA

@@ -0,0 +1,26 @@
+Metadata-Version: 2.1
+Name: langgraph-api
+Version: 0.0.1
+Summary: 
+License: Elastic-2.0
+Author: Nuno Campos
+Author-email: nuno@langchain.dev
+Requires-Python: >=3.11.0,<4.0
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: cryptography (>=43.0.3,<44.0.0)
+Requires-Dist: httpx (>=0.27.0)
+Requires-Dist: jsonschema-rs (>=0.25.0,<0.26.0)
+Requires-Dist: langchain-core (>=0.2.38,<0.4.0)
+Requires-Dist: langgraph (>=0.2.52)
+Requires-Dist: langsmith (>=0.1.63,<0.2.0)
+Requires-Dist: orjson (>=3.10.1)
+Requires-Dist: pyjwt (>=2.9.0,<3.0.0)
+Requires-Dist: sse-starlette (>=2.1.0,<3.0.0)
+Requires-Dist: starlette (>=0.38.6)
+Requires-Dist: structlog (>=24.4.0,<25.0.0)
+Requires-Dist: tenacity (>=8.3.0,<9.0.0)
+Requires-Dist: uvicorn (>=0.26.0)
+Requires-Dist: watchfiles (>=0.13)

langgraph_api-0.0.1.dist-info/RECORD

@@ -0,0 +1,86 @@
+LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
+langgraph_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langgraph_api/api/__init__.py,sha256=tlMXuqnyJt99aSlUXwR-dS3w5X6sDDczJu4hbm2LP30,2057
+langgraph_api/api/assistants.py,sha256=Nup-Sk6HKgYxJfDZQ0tZIVuUnD18gVd7wSiSairOyZE,11252
+langgraph_api/api/meta.py,sha256=hueasWpTDQ6xYLo9Bzt2jhNH8XQRzreH8FTeFfnRoxQ,2700
+langgraph_api/api/openapi.py,sha256=zvKMMebBP28hLPMNt1kTtFK17aV9Tz-ok2okEM45XjA,906
+langgraph_api/api/runs.py,sha256=Z4PyBk11zvrbYxHeXy8uZimpc3LoAdpku3DEQa79IWU,15535
+langgraph_api/api/store.py,sha256=ZQ1O9m24WDR0l8bJxgw6nBjDxaWUVXM1hoOR1acA9eg,4096
+langgraph_api/api/threads.py,sha256=taU61XPcCEhBPCYPZcMDsgVDwwWUWJs8p-PrXFXWY48,8661
+langgraph_api/asyncio.py,sha256=XiFEllu-Kg4zAO084npHPYOPnLQRire3V75XrVQYMxE,6023
+langgraph_api/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langgraph_api/auth/langsmith/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langgraph_api/auth/langsmith/backend.py,sha256=uHeb5-h13NIjrX_LDAvfWYr3zpbJvlvbdUffch48hbM,2571
+langgraph_api/auth/langsmith/client.py,sha256=eKchvAom7hdkUXauD8vHNceBDDUijrFgdTV8bKd7x4Q,3998
+langgraph_api/auth/middleware.py,sha256=_gJTOskEaln4RUT2rVYdQGPJVAyAiq-orsL_eQ3CynE,1369
+langgraph_api/auth/noop.py,sha256=vDJmzG2vArJxVzdHePvrJWahEa0dvGnhc2LEMMeiFz0,391
+langgraph_api/cli.py,sha256=gpFhsGLeG8kFdG_gx5xBwZwuCdwct4HZqyKsFRCQm6E,6496
+langgraph_api/config.py,sha256=cG6eO4P_SZ2pKedb2b4n4vnBHRQr0aiECvGvOA8ZlJA,2259
+langgraph_api/cron_scheduler.py,sha256=DAzY2DsADzEpPVbG2BOSLTIufI93yeRswd71Aby_lV0,2257
+langgraph_api/errors.py,sha256=Bu_i5drgNTyJcLiyrwVE_6-XrSU50BHf9TDpttki9wQ,1690
+langgraph_api/graph.py,sha256=A9-l7cUvesyC3ymY_XFXxT02VG2kkoqbSYUDvjga5S0,9771
+langgraph_api/http.py,sha256=XrbyxpjtfSvnaWWh5ZLGpgZmY83WoDCrP_1GPguNiXI,4712
+langgraph_api/http_logger.py,sha256=Sxo_q-65tElauRvkzVLt9lJojgNdgtcHGBYD0IRyX7M,3146
+langgraph_api/js/.gitignore,sha256=qAah3Fq0HWAlfRj5ktZyC6QRQIsAolGLRGcRukA1XJI,33
+langgraph_api/js/build.mts,sha256=v4ZJFnfBJBuLn8g0q-Uab9sgNtcssXcFEI-CmMoiOBc,1301
+langgraph_api/js/client.mts,sha256=nmWjL3Zs9jm8JoKPp8nrNNeRzwISTMqcZqqsDGx0SYE,24189
+langgraph_api/js/global.d.ts,sha256=zR_zLYfpzyPfxpEFth5RgZoyfGulIXyZYPRf7cU0K0Y,106
+langgraph_api/js/package.json,sha256=glTUiod6sTKOXoGX7C7XcUXLeB_6Xa0hIw7MmJq2EY8,792
+langgraph_api/js/remote.py,sha256=n34B4X1sZW70vEF1hMQ4vn28BroZJt7_7BGaJ0TNeBU,23306
+langgraph_api/js/server_sent_events.py,sha256=DLgXOHauemt7706vnfDUCG1GI3TidKycSizccdz9KgA,3702
+langgraph_api/js/src/graph.mts,sha256=Gh2-TcCepeRhqMk8Bm1tWm5sv53y2FxgSclUTamnLNw,2636
+langgraph_api/js/src/hooks.mjs,sha256=IfPwixktR6W5FA8yNmmBVDVAaqBA549WZKuj1uQedVY,511
+langgraph_api/js/src/parser/parser.mts,sha256=wXre7teh8N8RYmGcyhZp4vMJd0kNnnFgoSGEyMVPzpQ,13007
+langgraph_api/js/src/parser/parser.worker.mjs,sha256=2K6D0GlUmkk7LE39I8mryB8VZVE3-N9Cblji-ArPhFo,386
+langgraph_api/js/src/schema/types.mts,sha256=SUj0vpvWVbID1mnGr2SUtumDBQkJ9zjfvJdoFP7DIzk,66536
+langgraph_api/js/src/schema/types.template.mts,sha256=c-FA0Ykzp4KvPyYA6a-hDf60KdQRMyFEjmGVJyD2OPM,2011
+langgraph_api/js/src/utils/importMap.mts,sha256=pX4TGOyUpuuWF82kXcxcv3-8mgusRezOGe6Uklm2O5A,1644
+langgraph_api/js/src/utils/pythonSchemas.mts,sha256=98IW7Z_VP7L_CHNRMb3_MsiV3BgLE2JsWQY_PQcRR3o,685
+langgraph_api/js/src/utils/serde.mts,sha256=5SO-wYPnPa8f-D6HQX5Oy3NX3nuziZM8vQMqc2tuxbk,531
+langgraph_api/js/tests/api.test.mts,sha256=tuOZFGYgPld4kfm-S_SNXBwm3Ugp7h2PPuGLIyCjn24,49654
+langgraph_api/js/tests/compose-postgres.yml,sha256=7VCpWUgPjCzybf6Gu6pT788sZsxUnTjhbmji6c33cVc,1639
+langgraph_api/js/tests/graphs/.gitignore,sha256=26J8MarZNXh7snXD5eTpV3CPFTht5Znv8dtHYCLNfkw,12
+langgraph_api/js/tests/graphs/agent.mts,sha256=_E0JUf1U_yXJeqOMEhl2QqbbdADZR4zpLhiZk8SEWRc,3686
+langgraph_api/js/tests/graphs/error.mts,sha256=l4tk89449dj1BnEF_0ZcfPt0Ikk1gl8L1RaSnRfr3xo,487
+langgraph_api/js/tests/graphs/langgraph.json,sha256=-wSU_9H2fraq7Tijq_dTuK8SBDYLHsnfrYgi2zYUK2o,155
+langgraph_api/js/tests/graphs/nested.mts,sha256=4G7jSOSaFVQAza-_ARbK-Iai1biLlF2DIPDZXf7PLIY,1245
+langgraph_api/js/tests/graphs/package.json,sha256=g6GuOmLghaTYMSFoAoYa7lrIZyPwOETKaJNec-yT9n8,118
+langgraph_api/js/tests/graphs/weather.mts,sha256=A7mLK3xW8h5B-ZyJNAyX2M2fJJwzPJzXs4DYesJwreQ,1655
+langgraph_api/js/tests/graphs/yarn.lock,sha256=6GvNkJgzMDmLiw13ilBXOyelM3YHwUFySTdSbtNBpY8,7255
+langgraph_api/js/tests/parser.test.mts,sha256=3zAbboUNhI-cY3hj4Ssr7J-sQXCBTeeI1ItrkG0Ftuk,26257
+langgraph_api/js/tests/utils.mts,sha256=2kTybJ3O7Yfe1q3ehDouqV54ibXkNzsPZ_wBZLJvY-4,421
+langgraph_api/js/yarn.lock,sha256=sDKfB7VCWOapKFBT5IgF_wQKMYuu5q92WNHrlk9NGgc,65156
+langgraph_api/lifespan.py,sha256=Uj7NV-NqxxD1fgx_umM9pVqclcy-VlqrIxDljyj2he0,1820
+langgraph_api/logging.py,sha256=tiDNrEFwqaIdL5ywZv908OXlzzfXsPCws9GXeoFtBV8,3367
+langgraph_api/metadata.py,sha256=mih2G7ScQxiqyUlbksVXkqR3Oo-pM1b6lXtzOsgR1sw,3044
+langgraph_api/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langgraph_api/models/run.py,sha256=nNhlG-l2P-DThFWYmCaar0UuPctadB9sH3CCWJfLqVc,8178
+langgraph_api/patch.py,sha256=94ddcTSZJe22JcpjxiSNjFZdYVnmeoWjk4IX4iBSoyk,1249
+langgraph_api/queue.py,sha256=m_LcZ_KZO1PVROQxlHXZDud7CYBroZv9M3oLJ4n_qYA,9456
+langgraph_api/route.py,sha256=Dzje_dSigJramglqkt4ERT9-cb2xFli7dx25ZV6B6mI,4147
+langgraph_api/schema.py,sha256=kEhwg9MUvlHKUDCvomRUts3ja53IlXHgz70H1_AXMvk,5138
+langgraph_api/serde.py,sha256=VoJ7Z1IuqrQGXFzEP1qijAITtWCrmjtVqlCRuScjXJI,3533
+langgraph_api/server.py,sha256=cCD2lVv0SZdgf0o797UfxUyjFwmoazJVCjl_j-8Ae7A,1523
+langgraph_api/sse.py,sha256=2wNodCOP2eg7a9mpSu0S3FQ0CHk2BBV_vv0UtIgJIcc,4034
+langgraph_api/state.py,sha256=8jx4IoTCOjTJuwzuXJKKFwo1VseHjNnw_CCq4x1SW14,2284
+langgraph_api/stream.py,sha256=8VaGGUbh4BC_NJrAHeuPZgeLmRY0E8wNC0UkobLViqQ,11022
+langgraph_api/utils.py,sha256=FI50tOFMVidV4-1TefouL1N-OJX41qD_fSEoWigTtf0,1575
+langgraph_api/validation.py,sha256=McizHlz-Ez8Jhdbc79mbPSde7GIuf2Jlbjx2yv_l6dA,4475
+langgraph_license/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langgraph_license/middleware.py,sha256=_ODIYzQkymr6W9_Fp9wtf1kAQspnpsmr53xuzyF2GA0,612
+langgraph_license/validation.py,sha256=th7OP0JZ8R8uf7vKRpfl0K3LOI0dyCKBPBxwdmgcDOk,202
+langgraph_storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langgraph_storage/checkpoint.py,sha256=9mJTKXo4LIatr0nD7AX2mU8p9q18XaRnSSi25kNQcGc,2691
+langgraph_storage/database.py,sha256=0bB4y2rWBYiT4Jsmvbbsams4Q8G0CgEwPVwclz6iQrM,4924
+langgraph_storage/ops.py,sha256=0btWlZnl7hl3KC7C9IIKzlsmUPilF-MQe4WwLVLymfs,51884
+langgraph_storage/queue.py,sha256=6cTZ0ubHu3S1T43yxHMVOwsQsDaJupByiU0sTUFFls8,3261
+langgraph_storage/retry.py,sha256=uvYFuXJ-T6S1QY1ZwkZHyZQbsvS-Ab68LSbzbUUSI2E,696
+langgraph_storage/store.py,sha256=Z033CojJb6jMZbMu3VPtwR0bFdfyfdUS8dQSaXUASYU,731
+langgraph_storage/ttl_dict.py,sha256=FlpEY8EANeXWKo_G5nmIotPquABZGyIJyk6HD9u6vqY,1533
+logging.json,sha256=3RNjSADZmDq38eHePMm1CbP6qZ71AmpBtLwCmKU9Zgo,379
+openapi.json,sha256=JaieC_zSdQ9bzqJYdHUfCOnNt0ALBWcdj7uVjRLh9M8,122950
+langgraph_api-0.0.1.dist-info/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
+langgraph_api-0.0.1.dist-info/METADATA,sha256=Q9T28mju11J_KEkHOBUGUlbg2ig5g1atanoHMKCpKKs,932
+langgraph_api-0.0.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+langgraph_api-0.0.1.dist-info/entry_points.txt,sha256=3EYLgj89DfzqJHHYGxPH4A_fEtClvlRbWRUHaXO7hj4,77
+langgraph_api-0.0.1.dist-info/RECORD,,

langgraph_api-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any

langgraph_api-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+langgraph-verify-graphs=langgraph_api.graph:verify_graphs
+

langgraph_license/middleware.py

@@ -0,0 +1,21 @@
+"""Middleware for license validation."""
+
+from typing import Any
+
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+from starlette.responses import Response
+from starlette.types import ASGIApp
+
+
+class LicenseValidationMiddleware(BaseHTTPMiddleware):
+    """Noop license middleware"""
+
+    def __init__(self, app: ASGIApp):
+        """Initialize middleware."""
+        super().__init__(app)
+
+    async def dispatch(self, request: Request, call_next: Any) -> Response:
+        """Noop middleware."""
+        response = await call_next(request)
+        return response

langgraph_license/validation.py

@@ -0,0 +1,11 @@
+"""Noop license middleware"""
+
+
+async def get_license_status() -> bool:
+    """Always return true"""
+    return True
+
+
+def plus_features_enabled() -> bool:
+    """Always return true"""
+    return False

langgraph_storage/checkpoint.py

@@ -0,0 +1,94 @@
+import os
+import uuid
+
+from langchain_core.runnables import RunnableConfig
+from langgraph.checkpoint.base import (
+    Checkpoint,
+    CheckpointMetadata,
+    CheckpointTuple,
+    SerializerProtocol,
+)
+from langgraph.checkpoint.memory import MemorySaver, PersistentDict
+
+_EXCLUDED_KEYS = {"checkpoint_ns", "checkpoint_id", "run_id", "thread_id"}
+
+
+class InMemorySaver(MemorySaver):
+    def __init__(
+        self,
+        *,
+        serde: SerializerProtocol | None = None,
+    ) -> None:
+        self.filename = os.path.join(".langgraph_api", ".langgraph_checkpoint.")
+        i = 0
+
+        def factory(*args):
+            nonlocal i
+            i += 1
+
+            thisfname = self.filename + str(i) + ".pckl"
+            d = PersistentDict(*args, filename=thisfname)
+            if not os.path.exists(".langgraph_api"):
+                os.mkdir(".langgraph_api")
+            try:
+                d.load()
+            except FileNotFoundError:
+                pass
+            return d
+
+        super().__init__(
+            serde=serde,
+            factory=factory,
+        )
+
+    def put(
+        self,
+        config: RunnableConfig,
+        checkpoint: Checkpoint,
+        metadata: CheckpointMetadata,
+        new_versions: dict[str, str | int | float],
+    ) -> RunnableConfig:
+        # TODO: Should this be done in OSS as well?
+        metadata = {
+            **{
+                k: v
+                for k, v in config["configurable"].items()
+                if not k.startswith("__") and k not in _EXCLUDED_KEYS
+            },
+            **config.get("metadata", {}),
+            **metadata,
+        }
+        if not isinstance(checkpoint["id"], uuid.UUID):
+            # Avoid type inconsistencies
+            checkpoint = checkpoint.copy()
+            checkpoint["id"] = str(checkpoint["id"])
+        return super().put(config, checkpoint, metadata, new_versions)
+
+    def get_tuple(self, config: RunnableConfig) -> CheckpointTuple | None:
+        if isinstance(config["configurable"].get("checkpoint_id"), uuid.UUID):
+            # Avoid type inconsistencies....
+            config = config.copy()
+
+            config["configurable"] = {
+                **config["configurable"],
+                "checkpoint_id": str(config["configurable"]["checkpoint_id"]),
+            }
+        return super().get_tuple(config)
+
+    def clear(self):
+        self.storage.clear()
+        self.writes.clear()
+        for suffix in ["1", "2"]:
+            file_path = f"{self.filename}{suffix}.pckl"
+            if os.path.exists(file_path):
+                os.remove(file_path)
+
+
+MEMORY = InMemorySaver()
+
+
+def Checkpointer(*args, **kwargs):
+    return MEMORY
+
+
+__all__ = ["Checkpointer"]

langgraph_storage/database.py

@@ -0,0 +1,190 @@
+import asyncio
+import os
+import threading
+import uuid
+from collections import defaultdict
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from datetime import datetime
+from typing import Any, NotRequired, TypedDict
+from uuid import UUID
+
+import structlog
+from langgraph.checkpoint.memory import PersistentDict
+
+from langgraph_api.utils import AsyncConnectionProto
+from langgraph_storage.queue import start_queue, stop_queue
+
+logger = structlog.stdlib.get_logger(__name__)
+
+
+class Assistant(TypedDict):
+    assistant_id: UUID
+    graph_id: str
+    created_at: NotRequired[datetime]
+    updated_at: NotRequired[datetime]
+    config: dict[str, Any]
+    metadata: dict[str, Any]
+
+
+class Thread(TypedDict):
+    thread_id: UUID
+    created_at: NotRequired[datetime]
+    updated_at: NotRequired[datetime]
+    metadata: dict[str, Any]
+    status: str
+
+
+class Run(TypedDict):
+    run_id: UUID
+    thread_id: UUID
+    assistant_id: UUID
+    created_at: NotRequired[datetime]
+    updated_at: NotRequired[datetime]
+    metadata: dict[str, Any]
+    status: str
+
+
+class RunEvent(TypedDict):
+    event_id: UUID
+    run_id: UUID
+    received_at: NotRequired[datetime]
+    span_id: UUID
+    event: str
+    name: str
+    tags: list[Any]
+    data: dict[str, Any]
+    metadata: dict[str, Any]
+
+
+class AssistantVersion(TypedDict):
+    assistant_id: UUID
+    version: int
+    graph_id: str
+    config: dict[str, Any]
+    metadata: dict[str, Any]
+    created_at: NotRequired[datetime]
+
+
+class GlobalStore(PersistentDict):
+    def __init__(self, *args: Any, filename: str, **kwargs: Any) -> None:
+        super().__init__(*args, filename=filename, **kwargs)
+        self.clear()
+
+    def clear(self):
+        assistants = self.get("assistants", [])
+        super().clear()
+        self["runs"] = []
+        self["threads"] = []
+        self["assistants"] = [
+            a for a in assistants if a["metadata"].get("created_by") == "system"
+        ]
+        self["assistant_versions"] = []
+
+
+OPS_FILENAME = os.path.join(".langgraph_api", ".langgraph_ops.pckl")
+RETRY_COUNTER_FILENAME = os.path.join(".langgraph_api", ".langgraph_retry_counter.pckl")
+
+
+class InMemoryRetryCounter:
+    def __init__(self):
+        self._counters: dict[uuid.UUID, int] = PersistentDict(
+            int, filename=RETRY_COUNTER_FILENAME
+        )
+        self._locks: dict[uuid.UUID, asyncio.Lock] = defaultdict(asyncio.Lock)
+
+    async def increment(self, run_id: uuid.UUID) -> int:
+        async with self._locks[run_id]:
+            self._counters[run_id] += 1
+            return self._counters[run_id]
+
+    def close(self):
+        self._counters.close()
+
+
+# Global retry counter for in-memory implementation
+GLOBAL_RETRY_COUNTER = InMemoryRetryCounter()
+GLOBAL_STORE = GlobalStore(filename=OPS_FILENAME)
+
+
+class LockDict(defaultdict):
+    def __init__(self, *args, **kwargs):
+        self.__masterlock__ = threading.Lock()
+        super().__init__(*args, **kwargs)
+
+    def __getitem__(self, key):
+        with self.__masterlock__:
+            return super().__getitem__(key)
+
+
+GLOBAL_LOCKS = LockDict(threading.Lock)
+
+
+class InMemConnectionProto:
+    def __init__(self):
+        self.filename = OPS_FILENAME
+        self.store = GLOBAL_STORE
+        self.retry_counter = GLOBAL_RETRY_COUNTER
+        self.can_execute = False
+        self.locks = GLOBAL_LOCKS
+
+    @asynccontextmanager
+    async def pipeline(self):
+        yield None
+
+    async def execute(self, query: str, *args, **kwargs):
+        return None
+
+    def clear(self):
+        self.store.clear()
+        self.locks.clear()
+        keys = list(self.retry_counter._counters)
+        for key in keys:
+            del self.retry_counter._counters[key]
+        keys = list(self.retry_counter._locks)
+        for key in keys:
+            del self.retry_counter._locks[key]
+        if os.path.exists(self.filename):
+            os.remove(self.filename)
+
+
+@asynccontextmanager
+async def connect(*, __test__: bool = False) -> AsyncIterator[AsyncConnectionProto]:
+    yield InMemConnectionProto()
+
+
+async def start_pool() -> None:
+    if not os.path.exists(".langgraph_api"):
+        os.mkdir(".langgraph_api")
+    if os.path.exists(OPS_FILENAME):
+        GLOBAL_STORE.load()
+    for k in ["runs", "threads", "assistants", "assistant_versions"]:
+        if not GLOBAL_STORE.get(k):
+            GLOBAL_STORE[k] = []
+    for k in ["crons"]:
+        if not GLOBAL_STORE.get(k):
+            GLOBAL_STORE[k] = {}
+    await start_queue()
+
+
+async def stop_pool() -> None:
+    GLOBAL_STORE.close()
+    GLOBAL_RETRY_COUNTER.close()
+    from langgraph_storage.checkpoint import Checkpointer
+    from langgraph_storage.store import STORE
+
+    STORE.close()
+
+    async with Checkpointer():
+        pass
+    await stop_queue()
+
+
+async def healthcheck() -> None:
+    # What could possibly go wrong?
+    pass
+
+
+def pool_stats() -> dict[str, dict[str, int]]:
+    # TODO??
+    return {}