langgraph-api 0.0.3__tar.gz → 0.0.5__tar.gz

{langgraph_api-0.0.3 → langgraph_api-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langgraph-api
-Version: 0.0.3
+Version: 0.0.5
 Summary: 
 License: Elastic-2.0
 Author: Nuno Campos
@@ -15,7 +15,7 @@ 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,<0.3.0)
-Requires-Dist: langgraph-checkpoint (>=2.0.5,<3.0)
+Requires-Dist: langgraph-checkpoint (>=2.0.7,<3.0)
 Requires-Dist: langsmith (>=0.1.63,<0.2.0)
 Requires-Dist: orjson (>=3.10.1)
 Requires-Dist: pyjwt (>=2.9.0,<3.0.0)

{langgraph_api-0.0.3 → langgraph_api-0.0.5}/langgraph_api/api/assistants.py

@@ -121,7 +121,7 @@ async def get_assistant_graph(
         assistant_ = await Assistants.get(conn, assistant_id)
     assistant = await fetchone(assistant_)
     config = await ajson_loads(assistant["config"])
-    graph = get_graph(assistant["graph_id"], config)
+    graph = await get_graph(assistant["graph_id"], config)
 
     xray: bool | int = False
     xray_query = request.query_params.get("xray")
@@ -156,7 +156,7 @@ async def get_assistant_subgraphs(
         assistant_ = await Assistants.get(conn, assistant_id)
     assistant = await fetchone(assistant_)
     config = await ajson_loads(assistant["config"])
-    graph = get_graph(assistant["graph_id"], config)
+    graph = await get_graph(assistant["graph_id"], config)
     namespace = request.path_params.get("namespace")
 
     if isinstance(graph, RemotePregel):
@@ -191,7 +191,7 @@ async def get_assistant_schemas(
         assistant_ = await Assistants.get(conn, assistant_id)
     assistant = await fetchone(assistant_)
     config = await ajson_loads(assistant["config"])
-    graph = get_graph(assistant["graph_id"], config)
+    graph = await get_graph(assistant["graph_id"], config)
 
     if isinstance(graph, RemotePregel):
         schemas = await graph.fetch_state_schema()

{langgraph_api-0.0.3 → langgraph_api-0.0.5}/langgraph_api/api/store.py

@@ -73,12 +73,14 @@ async def search_items(request: ApiRequest):
     filter = payload.get("filter")
     limit = payload.get("limit") or 10
     offset = payload.get("offset") or 0
+    query = payload.get("query")
     async with connect() as conn:
         items = await Store(conn).asearch(
             namespace_prefix,
             filter=filter,
             limit=limit,
             offset=offset,
+            query=query,
         )
     return ApiResponse({"items": [item.dict() for item in items]})
 

{langgraph_api-0.0.3 → langgraph_api-0.0.5}/langgraph_api/cli.py

@@ -5,11 +5,34 @@ import os
 import pathlib
 import threading
 from collections.abc import Mapping, Sequence
+from typing import Any, TypedDict
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 
+def _get_org_id() -> str | None:
+    from langsmith.client import Client
+    from langsmith.utils import tracing_is_enabled
+
+    # Yes, the organizationId is actually the workspace iD
+    # which is actually the tenantID which we actually get via
+    # the sessions endpoint
+    if not tracing_is_enabled():
+        return
+    client = Client()
+    try:
+        response = client.request_with_retries(
+            "GET", "/api/v1/sessions", params={"limit": 1}
+        )
+        result = response.json()
+        if result:
+            return result[0]["tenant_id"]
+    except Exception as e:
+        logger.debug("Failed to get organization ID: %s", str(e))
+        return None
+
+
 @contextlib.contextmanager
 def patch_environment(**kwargs):
     """Temporarily patch environment variables.
@@ -37,6 +60,44 @@ def patch_environment(**kwargs):
                 os.environ[key] = value
 
 
+class IndexConfig(TypedDict, total=False):
+    """Configuration for indexing documents for semantic search in the store."""
+
+    dims: int
+    """Number of dimensions in the embedding vectors.
+    
+    Common embedding models have the following dimensions:
+        - OpenAI text-embedding-3-large: 256, 1024, or 3072
+        - OpenAI text-embedding-3-small: 512 or 1536
+        - OpenAI text-embedding-ada-002: 1536
+        - Cohere embed-english-v3.0: 1024
+        - Cohere embed-english-light-v3.0: 384
+        - Cohere embed-multilingual-v3.0: 1024
+        - Cohere embed-multilingual-light-v3.0: 384
+    """
+
+    embed: str
+    """Either a path to an embedding model (./path/to/file.py:embedding_model)
+    or a name of an embedding model (openai:text-embedding-3-small)
+    
+    Note: LangChain is required to use the model format specification.
+    """
+
+    fields: list[str] | None
+    """Fields to extract text from for embedding generation.
+    
+    Defaults to the root ["$"], which embeds the json object as a whole.
+    """
+
+
+class StoreConfig(TypedDict, total=False):
+    index: IndexConfig
+
+
+class Config(TypedDict, total=False):
+    store: StoreConfig | None
+
+
 def run_server(
     host: str = "127.0.0.1",
     port: int = 2024,
@@ -49,6 +110,8 @@ def run_server(
     env: str | pathlib.Path | Mapping[str, str] | None = None,
     reload_includes: Sequence[str] | None = None,
     reload_excludes: Sequence[str] | None = None,
+    config: Config | None = None,
+    **kwargs: Any,
 ):
     """Run the LangGraph API server."""
     import uvicorn
@@ -92,19 +155,41 @@ def run_server(
     studio_url = f"https://smith.langchain.com/studio/?baseUrl={local_url}"
 
     def _open_browser():
+        nonlocal studio_url
         import time
         import urllib.request
         import webbrowser
+        from concurrent.futures import ThreadPoolExecutor
+
+        thread_logger = logging.getLogger("browser_opener")
+        if not thread_logger.handlers:
+            handler = logging.StreamHandler()
+            handler.setFormatter(logging.Formatter("%(message)s"))
+            thread_logger.addHandler(handler)
 
-        while True:
-            try:
-                with urllib.request.urlopen(f"{local_url}/ok") as response:
-                    if response.status == 200:
-                        webbrowser.open(studio_url)
-                        return
-            except urllib.error.URLError:
-                pass
-            time.sleep(0.1)
+        with ThreadPoolExecutor(max_workers=1) as executor:
+            org_id_future = executor.submit(_get_org_id)
+
+            while True:
+                try:
+                    with urllib.request.urlopen(f"{local_url}/ok") as response:
+                        if response.status == 200:
+                            try:
+                                org_id = org_id_future.result(timeout=3.0)
+                                if org_id:
+                                    studio_url = f"https://smith.langchain.com/studio/?baseUrl={local_url}&organizationId={org_id}"
+                            except TimeoutError as e:
+                                thread_logger.debug(
+                                    f"Failed to get organization ID: {str(e)}"
+                                )
+                                pass
+                            thread_logger.info("🎨 Opening Studio in your browser...")
+                            thread_logger.info("URL: " + studio_url)
+                            webbrowser.open(studio_url)
+                            return
+                except urllib.error.URLError:
+                    pass
+                time.sleep(0.1)
 
     welcome = f"""
 
@@ -128,13 +213,13 @@ For production use, please use LangGraph Cloud.
         DATABASE_URI=":memory:",
         REDIS_URI="fake",
         N_JOBS_PER_WORKER=str(n_jobs_per_worker if n_jobs_per_worker else 1),
+        LANGGRAPH_CONFIG=json.dumps(config) if config else None,
         LANGSERVE_GRAPHS=json.dumps(graphs) if graphs else None,
         LANGSMITH_LANGGRAPH_API_VARIANT="local_dev",
         **(env_vars or {}),
     ):
         if open_browser:
             threading.Thread(target=_open_browser, daemon=True).start()
-
         uvicorn.run(
             "langgraph_api.server:app",
             host=host,
@@ -158,6 +243,7 @@ For production use, please use LangGraph Cloud.
                 },
                 "root": {"handlers": ["console"]},
             },
+            **kwargs,
         )
 
 

{langgraph_api-0.0.3 → langgraph_api-0.0.5}/langgraph_api/graph.py

@@ -1,4 +1,5 @@
 import asyncio
+import functools
 import glob
 import importlib.util
 import inspect
@@ -8,7 +9,7 @@ import sys
 from collections.abc import Callable
 from itertools import filterfalse
 from random import choice
-from typing import NamedTuple
+from typing import TYPE_CHECKING, NamedTuple
 from uuid import UUID, uuid5
 
 import structlog
@@ -22,6 +23,9 @@ from starlette.exceptions import HTTPException
 from langgraph_api.js.remote import RemotePregel
 from langgraph_api.schema import Config
 
+if TYPE_CHECKING:
+    from langchain_core.embeddings import Embeddings
+
 logger = structlog.stdlib.get_logger(__name__)
 
 GraphFactoryFromConfig = Callable[[Config], Pregel | Graph]
@@ -55,7 +59,7 @@ async def register_graph(graph_id: str, graph: GraphValue, config: dict | None)
         )
 
 
-def get_graph(
+async def get_graph(
     graph_id: str,
     config: Config,
     *,
@@ -67,6 +71,8 @@ def get_graph(
     value = GRAPHS[graph_id]
     if graph_id in FACTORY_ACCEPTS_CONFIG:
         value = value(config) if FACTORY_ACCEPTS_CONFIG[graph_id] else value()
+        if asyncio.iscoroutine(value):
+            value = await value
     if isinstance(value, Graph):
         value = value.compile()
     if not isinstance(value, Pregel) and not isinstance(value, RemotePregel):
@@ -269,7 +275,7 @@ def _graph_from_spec(spec: GraphSpec) -> GraphValue:
             sys.modules[modname] = module
             modspec.loader.exec_module(module)
         except ImportError as e:
-            e.add_note(f"Could not import python module for graph: {spec}")
+            e.add_note(f"Could not import python module for graph:\n{spec}")
             if os.environ.get("LANGSMITH_LANGGRAPH_API_VARIANT") == "local_dev":
                 e.add_note(
                     "This error likely means you haven't installed your project and its dependencies yet. Before running the server, install your project:\n\n"
@@ -279,11 +285,44 @@ def _graph_from_spec(spec: GraphSpec) -> GraphValue:
                     "python -m pip install -e .\n\n"
                     "Make sure to run this command from your project's root directory (where your setup.py or pyproject.toml is located)"
                 )
+            raise
+        except FileNotFoundError as e:
+            e.add_note(f"Could not find python file for graph: {spec}")
+            raise
     else:
         raise ValueError("Graph specification must have a path or module")
 
     if spec.variable:
-        graph: GraphValue = getattr(module, spec.variable)
+        try:
+            graph: GraphValue = module.__dict__[spec.variable]
+        except KeyError as e:
+            available = [k for k in module.__dict__ if not k.startswith("__")]
+            suggestion = ""
+            if available:
+                likely = [
+                    k
+                    for k in available
+                    if isinstance(module.__dict__[k], Graph | Pregel)
+                ]
+                if likely:
+                    prefix = spec.module or spec.path
+                    likely_ = "\n".join(
+                        [f"\t- {prefix}:{k}" if prefix else k for k in likely]
+                    )
+                    suggestion = (
+                        f"\nDid you mean to use one of the following?\n{likely_}"
+                    )
+                elif available:
+                    suggestion = (
+                        f"\nFound the following exports: {', '.join(available)}"
+                    )
+
+            raise ValueError(
+                f"Could not find graph '{spec.variable}' in '{spec.path}'. "
+                f"Please check that:\n"
+                f"1. The file exports a variable named '{spec.variable}'\n"
+                f"2. The variable name in your config matches the export name{suggestion}"
+            ) from e
         if callable(graph):
             sig = inspect.signature(graph)
             if not sig.parameters:
@@ -322,3 +361,105 @@ def _graph_from_spec(spec: GraphSpec) -> GraphValue:
                 )
 
     return graph
+
+
+def _load(path: str, variable: str) -> None:
+    modname = "".join(choice("abcdefghijklmnopqrstuvwxyz") for _ in range(24))
+    modspec = importlib.util.spec_from_file_location(modname, path)
+    if modspec is None:
+        raise ValueError(f"Could not find python file for embeddings: {path}")
+    module = importlib.util.module_from_spec(modspec)
+    sys.modules[modname] = module
+    modspec.loader.exec_module(module)
+    return module.__dict__[variable]
+
+
+@functools.lru_cache
+def _get_init_embeddings() -> Callable[[str, ...], "Embeddings"] | None:
+    try:
+        from langchain.embeddings import init_embeddings
+
+        return init_embeddings
+    except ImportError:
+        return None
+
+
+def resolve_embeddings(index_config: dict) -> "Embeddings":
+    """Return embeddings from config.
+
+    Args:
+        index_config: Configuration for the vector store index
+            Must contain an "embed" key specifying either:
+            - A path to a Python file and function (e.g. "./embeddings.py:get_embeddings")
+            - A LangChain embeddings identifier (e.g. "openai:text-embedding-3-small")
+
+    Returns:
+        Embeddings: A LangChain embeddings instance
+
+    Raises:
+        ValueError: If embeddings cannot be loaded from the config
+    """
+    from langchain_core.embeddings import Embeddings
+    from langgraph.store.base import ensure_embeddings
+
+    embed: str = index_config["embed"]
+    if ".py:" in embed:
+        module_name, function = embed.rsplit(":", 1)
+        module_name = module_name.rstrip(":")
+
+        try:
+            if "/" in module_name:
+                # Load from file path
+                modname = "".join(
+                    choice("abcdefghijklmnopqrstuvwxyz") for _ in range(24)
+                )
+                modspec = importlib.util.spec_from_file_location(modname, module_name)
+                if modspec is None:
+                    raise ValueError(f"Could not find embeddings file: {module_name}")
+                module = importlib.util.module_from_spec(modspec)
+                sys.modules[modname] = module
+                modspec.loader.exec_module(module)
+            else:
+                # Load from Python module
+                module = importlib.import_module(module_name)
+
+            embedding_fn = getattr(module, function, None)
+            if embedding_fn is None:
+                raise ValueError(
+                    f"Could not find embeddings function '{function}' in module: {module_name}"
+                )
+
+            if isinstance(embedding_fn, Embeddings):
+                return embedding_fn
+            elif not callable(embedding_fn):
+                raise ValueError(
+                    f"Embeddings function '{function}' in module: {module_name} is not callable"
+                )
+
+            return ensure_embeddings(embedding_fn)
+
+        except ImportError as e:
+            e.add_note(f"Could not import embeddings module:\n{module_name}\n\n")
+            if os.environ.get("LANGSMITH_LANGGRAPH_API_VARIANT") == "local_dev":
+                e.add_note(
+                    "If you're in development mode, make sure you've installed your project "
+                    "and its dependencies:\n"
+                    "- For requirements.txt: pip install -r requirements.txt\n"
+                    "- For pyproject.toml: pip install -e .\n"
+                )
+            raise
+        except FileNotFoundError as e:
+            raise ValueError(f"Could not find embeddings file: {module_name}") from e
+
+    else:
+        # Load from LangChain embeddings
+        init_embeddings = _get_init_embeddings()
+        if init_embeddings is None:
+            raise ValueError(
+                f"Could not load LangChain embeddings '{embed}'. "
+                "Loading embeddings by provider:identifier requires the langchain package (>=0.3.9). "
+                "Install it with: pip install 'langchain>=0.3.9'"
+                " or specify 'embed' as a path to a "
+                "variable in a Python file instead."
+            )
+        return init_embeddings(embed)

{langgraph_api-0.0.3 → langgraph_api-0.0.5}/langgraph_api/js/package.json

@@ -10,7 +10,7 @@
     "@hono/node-server": "^1.12.0",
     "@hono/zod-validator": "^0.2.2",
     "@langchain/core": "^0.3.17",
-    "@langchain/langgraph": "^0.2.20",
+    "@langchain/langgraph": "^0.2.23",
     "@types/json-schema": "^7.0.15",
     "@typescript/vfs": "^1.6.0",
     "dedent": "^1.5.3",

{langgraph_api-0.0.3 → langgraph_api-0.0.5}/langgraph_api/js/yarn.lock

@@ -345,10 +345,10 @@
     p-retry "4"
     uuid "^9.0.0"
 
-"@langchain/langgraph@^0.2.20":
-  version "0.2.22"
-  resolved "https://registry.yarnpkg.com/@langchain/langgraph/-/langgraph-0.2.22.tgz#32834e147f16def2e9b491b2c09ecd349714d7f9"
-  integrity sha512-iXA8p9xaWfGviBbZ6nOETqvGz2misjZ4xGxrWla98FF2aE8mq1jfMzWuEX37KZIfuQPCqt1iIh/Zit60T4mG3Q==
+"@langchain/langgraph@^0.2.23":
+  version "0.2.23"
+  resolved "https://registry.yarnpkg.com/@langchain/langgraph/-/langgraph-0.2.23.tgz#b892ae642c2ac49a44599ce18ab1897b14554f9f"
+  integrity sha512-aUD3G2cUSmrOb6xtJkd0AUctmHJXuyNPIzMR86JMEN591AtkHTVe2OhTxo15S8PPAQxJ7HrCJyMFd0EQECRASw==
   dependencies:
     "@langchain/langgraph-checkpoint" "~0.0.12"
     "@langchain/langgraph-sdk" "~0.0.21"

{langgraph_api-0.0.3 → langgraph_api-0.0.5}/langgraph_api/server.py

@@ -23,7 +23,6 @@ from langgraph_storage.retry import OVERLOADED_EXCEPTIONS
 logging.captureWarnings(True)
 logger = structlog.stdlib.get_logger(__name__)
 
-
 app = Starlette(
     routes=routes,
     lifespan=lifespan,

{langgraph_api-0.0.3 → langgraph_api-0.0.5}/langgraph_api/stream.py

@@ -94,16 +94,16 @@ async def astream_state(
 ) -> AnyStream:
     """Stream messages from the runnable."""
     run_id = str(run["run_id"])
-    await stack.enter_async_context(conn.pipeline())
+    pipe = await stack.enter_async_context(conn.pipeline())
     # extract args from run
     kwargs = run["kwargs"].copy()
     subgraphs = kwargs.get("subgraphs", False)
     temporary = kwargs.pop("temporary", False)
     config = kwargs.pop("config")
-    graph = get_graph(
+    graph = await get_graph(
         config["configurable"]["graph_id"],
         config,
-        store=None if not conn else Store(conn),
+        store=None if not conn else Store(conn, pipe=pipe),
         checkpointer=None if temporary else Checkpointer(conn),
     )
     input = kwargs.pop("input")
@@ -188,9 +188,11 @@ async def astream_state(
                                 messages[msg.id] = msg
                                 yield "messages/metadata", {msg.id: {"metadata": meta}}
                             yield (
-                                "messages/partial"
-                                if isinstance(msg, BaseMessageChunk)
-                                else "messages/complete",
+                                (
+                                    "messages/partial"
+                                    if isinstance(msg, BaseMessageChunk)
+                                    else "messages/complete"
+                                ),
                                 [message_chunk_to_message(messages[msg.id])],
                             )
                     elif mode in stream_mode:
@@ -237,9 +239,11 @@ async def astream_state(
                             messages[msg.id] = msg
                             yield "messages/metadata", {msg.id: {"metadata": meta}}
                         yield (
-                            "messages/partial"
-                            if isinstance(msg, BaseMessageChunk)
-                            else "messages/complete",
+                            (
+                                "messages/partial"
+                                if isinstance(msg, BaseMessageChunk)
+                                else "messages/complete"
+                            ),
                             [message_chunk_to_message(messages[msg.id])],
                         )
                 elif mode in stream_mode:

{langgraph_api-0.0.3 → langgraph_api-0.0.5}/langgraph_storage/database.py

@@ -1,4 +1,5 @@
 import asyncio
+import json
 import os
 import threading
 import uuid
@@ -13,6 +14,7 @@ import structlog
 from langgraph.checkpoint.memory import PersistentDict
 
 from langgraph_api.utils import AsyncConnectionProto
+from langgraph_storage import store
 from langgraph_storage.queue import start_queue, stop_queue
 
 logger = structlog.stdlib.get_logger(__name__)
@@ -154,6 +156,12 @@ async def connect(*, __test__: bool = False) -> AsyncIterator[AsyncConnectionPro
 
 
 async def start_pool() -> None:
+    if store._STORE_CONFIG is None:
+        if (config_val := os.getenv("LANGGRAPH_CONFIG")) and config_val.strip():
+            config_ = json.loads(config_val.strip())
+            if "store" in config_:
+                store.set_store_config(config_["store"])
+
     if not os.path.exists(".langgraph_api"):
         os.mkdir(".langgraph_api")
     if os.path.exists(OPS_FILENAME):

{langgraph_api-0.0.3 → langgraph_api-0.0.5}/langgraph_storage/ops.py

@@ -719,7 +719,9 @@ class Threads:
             if graph_id := metadata.get("graph_id"):
                 # format latest checkpoint for response
                 checkpointer.latest_iter = checkpoint
-                graph = get_graph(graph_id, thread_config, checkpointer=checkpointer)
+                graph = await get_graph(
+                    graph_id, thread_config, checkpointer=checkpointer
+                )
                 result = await graph.aget_state(config, subgraphs=subgraphs)
                 if (
                     result.metadata is not None
@@ -766,7 +768,9 @@ class Threads:
                 config["configurable"].setdefault("graph_id", graph_id)
 
                 checkpointer.latest_iter = checkpoint
-                graph = get_graph(graph_id, thread_config, checkpointer=checkpointer)
+                graph = await get_graph(
+                    graph_id, thread_config, checkpointer=checkpointer
+                )
                 update_config = config.copy()
                 update_config["configurable"] = {
                     **config["configurable"],
@@ -820,7 +824,7 @@ class Threads:
             thread_config = thread["config"]
             # If graph_id exists, get state history
             if graph_id := thread_metadata.get("graph_id"):
-                graph = get_graph(
+                graph = await get_graph(
                     graph_id, thread_config, checkpointer=Checkpointer(conn)
                 )
 

langgraph_api-0.0.5/langgraph_storage/store.py

@@ -0,0 +1,62 @@
+import os
+from collections import defaultdict
+from typing import Any
+
+from langgraph.checkpoint.memory import PersistentDict
+from langgraph.store.memory import InMemoryStore
+
+from langgraph_api.graph import resolve_embeddings
+
+_STORE_CONFIG = None
+
+
+class DiskBackedInMemStore(InMemoryStore):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self._data = PersistentDict(dict, filename=_STORE_FILE)
+        self._vectors = PersistentDict(lambda: defaultdict(dict), filename=_VECTOR_FILE)
+        self._load_data(self._data, which="data")
+        self._load_data(self._vectors, which="vectors")
+
+    def _load_data(self, container: PersistentDict, which: str) -> None:
+        if not container.filename:
+            return
+        try:
+            container.load()
+        except FileNotFoundError:
+            # It's okay if the file doesn't exist yet
+            pass
+
+        except (EOFError, ValueError) as e:
+            raise RuntimeError(
+                f"Failed to load store {which} from {container.filename}. "
+                "This may be due to changes in the stored data structure. "
+                "Consider clearing the local store by running: rm -rf .langgraph_api"
+            ) from e
+        except Exception as e:
+            raise RuntimeError(
+                f"Unexpected error loading store {which} from {container.filename}: {str(e)}"
+            ) from e
+
+    def close(self) -> None:
+        self._data.close()
+        self._vectors.close()
+
+
+_STORE_FILE = os.path.join(".langgraph_api", "store.pckl")
+_VECTOR_FILE = os.path.join(".langgraph_api", "store.vectors.pckl")
+os.makedirs(".langgraph_api", exist_ok=True)
+STORE = DiskBackedInMemStore()
+
+
+def set_store_config(config) -> None:
+    global _STORE_CONFIG, STORE
+    _STORE_CONFIG = config.copy()
+    _STORE_CONFIG["index"]["embed"] = resolve_embeddings(_STORE_CONFIG.get("index", {}))
+    # Re-create the store
+    STORE.close()
+    STORE = DiskBackedInMemStore(index=_STORE_CONFIG.get("index", {}))
+
+
+def Store(*args: Any, **kwargs: Any) -> DiskBackedInMemStore:
+    return STORE

{langgraph_api-0.0.3 → langgraph_api-0.0.5}/openapi.json

@@ -1557,8 +1557,11 @@
           "200": {
             "description": "Success",
             "content": {
-              "application/json": {
-                "schema": {}
+              "text/event-stream": {
+                "schema": {
+                  "type": "string",
+                  "description": "The server will send a stream of events in SSE format.\n\n**Example event**:\n\nid: 1\n\nevent: message\n\ndata: {}"
+                }
               }
             }
           },
@@ -1905,8 +1908,11 @@
           "200": {
             "description": "Success",
             "content": {
-              "application/json": {
-                "schema": {}
+              "text/event-stream": {
+                "schema": {
+                  "type": "string",
+                  "description": "The server will send a stream of events in SSE format.\n\n**Example event**:\n\nid: 1\n\nevent: message\n\ndata: {}"
+                }
               }
             }
           },
@@ -2143,8 +2149,11 @@
           "200": {
             "description": "Success",
             "content": {
-              "application/json": {
-                "schema": {}
+              "text/event-stream": {
+                "schema": {
+                  "type": "string",
+                  "description": "The server will send a stream of events in SSE format.\n\n**Example event**:\n\nid: 1\n\nevent: message\n\ndata: {}"
+                }
               }
             }
           },

{langgraph_api-0.0.3 → langgraph_api-0.0.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langgraph-api"
-version = "0.0.3"
+version = "0.0.5"
 description = ""
 authors = [
     "Nuno Campos <nuno@langchain.dev>",
@@ -24,7 +24,7 @@ sse-starlette = "^2.1.0"
 starlette = ">=0.38.6"
 watchfiles = ">=0.13"
 langgraph = ">=0.2.52,<0.3.0"
-langgraph-checkpoint = ">=2.0.5,<3.0"
+langgraph-checkpoint = ">=2.0.7,<3.0"
 orjson = ">=3.10.1"
 uvicorn = ">=0.26.0"
 langsmith = "^0.1.63"

langgraph_api-0.0.3/langgraph_storage/store.py

@@ -1,28 +0,0 @@
-import os
-
-from langgraph.checkpoint.memory import PersistentDict
-from langgraph.store.memory import InMemoryStore
-
-
-class DiskBackedInMemStore(InMemoryStore):
-    def __init__(self, *args, filename=None, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.filename = filename
-        self._data = PersistentDict(dict, filename=self.filename)
-        try:
-            self._data.load()
-        except FileNotFoundError:
-            pass
-
-    def close(self):
-        self._data.close()
-
-
-_STORE_FILE = os.path.join(".langgraph_api", "store.pckl")
-if not os.path.exists(".langgraph_api"):
-    os.mkdir(".langgraph_api")
-STORE = DiskBackedInMemStore(filename=_STORE_FILE)
-
-
-def Store(*args, **kwargs):
-    return STORE