Upload 459 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+langgraph/source/libs/cli/js-examples/static/studio.png filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.10
+
+RUN useradd -m -u 1000 user && python -m pip install --upgrade pip
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+ENV MCP_TRANSPORT=http
+ENV MCP_PORT=7860
+
+EXPOSE 7860
+
+CMD ["python", "langgraph/mcp_output/start_mcp.py"]

README.md

@@ -1,10 +1,32 @@
 ---
-title: Langgraph
-emoji: ⚡
-colorFrom: green
-colorTo: green
+title: Langgraph MCP
+emoji: 🤖
+colorFrom: blue
+colorTo: purple
 sdk: docker
+sdk_version: "4.26.0"
+app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Langgraph MCP Service
+
+Auto-generated MCP service for langgraph.
+
+## Usage
+
+```
+https://None-langgraph-mcp.hf.space/mcp
+```
+
+## Connect with Cursor
+
+```json
+{
+  "mcpServers": {
+    "langgraph": {
+      "url": "https://None-langgraph-mcp.hf.space/mcp"
+    }
+  }
+}
+```

app.py

@@ -0,0 +1,45 @@
+from fastapi import FastAPI
+import os
+import sys
+
+mcp_plugin_path = os.path.join(os.path.dirname(__file__), "langgraph", "mcp_output", "mcp_plugin")
+sys.path.insert(0, mcp_plugin_path)
+
+app = FastAPI(
+    title="Langgraph MCP Service",
+    description="Auto-generated MCP service for langgraph",
+    version="1.0.0"
+)
+
+@app.get("/")
+def root():
+    return {
+        "service": "Langgraph MCP Service",
+        "version": "1.0.0",
+        "status": "running",
+        "transport": os.environ.get("MCP_TRANSPORT", "http")
+    }
+
+@app.get("/health")
+def health_check():
+    return {"status": "healthy", "service": "langgraph MCP"}
+
+@app.get("/tools")
+def list_tools():
+    try:
+        from mcp_service import create_app
+        mcp_app = create_app()
+        tools = []
+        for tool_name, tool_func in mcp_app.tools.items():
+            tools.append({
+                "name": tool_name,
+                "description": tool_func.__doc__ or "No description available"
+            })
+        return {"tools": tools}
+    except Exception as e:
+        return {"error": f"Failed to load tools: {str(e)}"}
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.environ.get("PORT", 7860))
+    uvicorn.run(app, host="0.0.0.0", port=port)

langgraph/mcp_output/README_MCP.md

@@ -0,0 +1,57 @@
+# LangGraph MCP (Model Context Protocol) Service
+
+## Project Introduction
+
+LangGraph is a framework designed for building stateful, multi-actor applications with Large Language Models (LLMs). It provides a low-level orchestration infrastructure for long-running, durable workflows without abstracting prompts or architecture. The core components include a Bulk Synchronous Parallel (BSP) execution model, state management, and checkpointing architecture, enabling developers to create complex, stateful applications efficiently.
+
+## Installation Method
+
+To install LangGraph and its dependencies, use the following pip command:
+
+pip install langgraph
+
+### Dependencies
+
+- Required: `pydantic`, `aiohttp`, `sqlalchemy`
+- Optional: `redis`, `pytest`
+
+## Quick Start
+
+To quickly get started with LangGraph, you can use the following example to create a simple graph:
+
+1. Define your graph using the `StateGraph` API or the `@entrypoint` and `@task` decorators.
+2. Compile and invoke your graph using the `Pregel` execution engine.
+3. Use the `InMemoryCheckpointSaver` for local development and testing.
+
+Example:
+
+from langgraph import StateGraph, Pregel
+
+graph = StateGraph()
+graph.add_node(...)
+graph.compile()
+
+pregel = Pregel(graph)
+pregel.invoke(...)
+
+## Available Tools and Endpoints List
+
+- **StateGraph API**: Provides methods like `add_node()`, `add_edge()`, and `compile()` to build graphs.
+- **Pregel Execution Engine**: Orchestrates execution in discrete steps, persisting checkpoints for durability.
+- **LangGraph CLI**: Offers commands like `dev`, `build`, and `up` for local development and Docker image generation.
+- **LangGraphClient (Python SDK)**: Enables interaction with remote LangGraph deployments.
+- **LangGraph Studio**: A visual debugging interface for graph execution.
+
+## Common Issues and Notes
+
+- Ensure all required dependencies are installed to avoid runtime errors.
+- For local development, use the `InMemoryCheckpointSaver` to avoid external dependencies.
+- When deploying to production, consider using `PostgresCheckpointSaver` for robust persistence.
+- Performance may vary based on the complexity of the graph and the execution environment.
+
+## Reference Links or Documentation
+
+- [LangGraph GitHub Repository](https://github.com/langchain-ai/langgraph)
+- [LangGraph Documentation](https://github.com/langchain-ai/langgraph/blob/main/README.md)
+
+For more detailed information on specific subsystems, refer to the documentation sections on package structure, graph building, state persistence, remote deployment, and development tools.

langgraph/mcp_output/diff_report.md

@@ -0,0 +1,61 @@
+# Langgraph Project Difference Report
+
+**Date:** February 7, 2026  
+**Time:** 14:44:29  
+**Repository:** langgraph  
+**Project Type:** Python Library  
+**Intrusiveness:** None  
+**Workflow Status:** Success  
+**Test Status:** Failed  
+
+## Project Overview
+
+The Langgraph project is a Python library designed to provide basic functionality for language graph operations. It aims to facilitate the manipulation and analysis of language data structures in a graph format. The project is currently under development and has recently undergone changes that include the addition of new files.
+
+## Difference Analysis
+
+### New Files Added
+
+A total of 8 new files have been introduced to the repository. These files are likely to contain new features or enhancements to the existing functionality. However, no existing files were modified during this update, indicating that the changes were additive rather than altering existing code.
+
+### Modified Files
+
+There were no modifications to existing files in this update. This suggests that the new features or functionalities were implemented in isolation, potentially minimizing the risk of introducing bugs into the existing codebase.
+
+## Technical Analysis
+
+### Workflow Status
+
+The workflow status is marked as "success," indicating that the automated processes for building and deploying the project were executed without errors. This suggests that the integration of new files did not disrupt the build process.
+
+### Test Status
+
+The test status is marked as "failed," which is a critical issue that needs immediate attention. This failure indicates that one or more tests did not pass, which could be due to the newly added files or existing issues that were not previously detected.
+
+## Recommendations and Improvements
+
+1. **Investigate Test Failures:** Conduct a thorough investigation into the test failures to identify the root cause. This may involve reviewing the new files for potential issues or ensuring that the tests themselves are correctly configured.
+
+2. **Enhance Test Coverage:** Ensure that the new files are covered by unit tests. This will help in identifying any issues early in the development process and improve the overall reliability of the library.
+
+3. **Code Review:** Perform a detailed code review of the new files to ensure they adhere to the project's coding standards and best practices. This can help in identifying potential issues that automated tests might miss.
+
+4. **Documentation Update:** Update the project documentation to reflect the new features and functionalities introduced by the new files. This will aid users in understanding and utilizing the new capabilities of the library.
+
+## Deployment Information
+
+Given the workflow status is successful, the deployment process for the new changes was executed without errors. However, due to the test failures, it is advisable to hold off on any production deployment until the issues are resolved.
+
+## Future Planning
+
+1. **Resolve Current Issues:** Prioritize resolving the test failures and any issues identified during the code review process.
+
+2. **Feature Expansion:** Plan for future enhancements and features that can be added to the library, keeping in mind the feedback from users and the current roadmap.
+
+3. **Community Engagement:** Engage with the community to gather feedback on the new features and identify areas for improvement.
+
+4. **Regular Updates:** Schedule regular updates and maintenance releases to ensure the library remains robust and up-to-date with the latest developments in the field.
+
+## Conclusion
+
+The recent update to the Langgraph project has introduced new files and features, but it has also resulted in test failures that need to be addressed. By following the recommendations outlined in this report, the project can improve its stability and continue to provide valuable functionality to its users.

langgraph/mcp_output/mcp_plugin/adapter.py

@@ -0,0 +1,215 @@
+import os
+import sys
+
+# Path settings
+source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
+sys.path.insert(0, source_path)
+
+# Import statements
+try:
+    from examples.chatbot_simulation_evaluation.simulation_utils import add_messages, create_chat_simulator, create_simulated_user, SimulationState
+    from libs.cli.generate_schema import add_descriptions_to_schema, generate_schema, main as generate_schema_main
+    from libs.cli.examples.my_app import MyContextMiddleware
+    from libs.cli.examples.graph_prerelease_reqs.agent import call_model, should_continue, AgentState, ContextSchema
+except ImportError as e:
+    print(f"Import error: {e}. Please ensure all dependencies are correctly installed.")
+
+# Adapter class
+class Adapter:
+    """
+    Adapter class to interface with the MCP plugin, utilizing functions and classes from the analysis result.
+    """
+
+    def __init__(self):
+        self.mode = "import"
+
+    # -------------------- Simulation Utilities --------------------
+
+    def create_simulation_state(self):
+        """
+        Create an instance of SimulationState.
+
+        Returns:
+            dict: Status and instance of SimulationState.
+        """
+        try:
+            instance = SimulationState()
+            return {"status": "success", "instance": instance}
+        except Exception as e:
+            return {"status": "error", "message": f"Failed to create SimulationState: {str(e)}"}
+
+    def call_add_messages(self, messages):
+        """
+        Call the add_messages function.
+
+        Args:
+            messages (list): List of messages to add.
+
+        Returns:
+            dict: Status and result of add_messages.
+        """
+        try:
+            result = add_messages(messages)
+            return {"status": "success", "result": result}
+        except Exception as e:
+            return {"status": "error", "message": f"Failed to add messages: {str(e)}"}
+
+    def call_create_chat_simulator(self, config):
+        """
+        Call the create_chat_simulator function.
+
+        Args:
+            config (dict): Configuration for the chat simulator.
+
+        Returns:
+            dict: Status and chat simulator instance.
+        """
+        try:
+            simulator = create_chat_simulator(config)
+            return {"status": "success", "simulator": simulator}
+        except Exception as e:
+            return {"status": "error", "message": f"Failed to create chat simulator: {str(e)}"}
+
+    def call_create_simulated_user(self, user_config):
+        """
+        Call the create_simulated_user function.
+
+        Args:
+            user_config (dict): Configuration for the simulated user.
+
+        Returns:
+            dict: Status and simulated user instance.
+        """
+        try:
+            user = create_simulated_user(user_config)
+            return {"status": "success", "user": user}
+        except Exception as e:
+            return {"status": "error", "message": f"Failed to create simulated user: {str(e)}"}
+
+    # -------------------- Schema Generation --------------------
+
+    def call_add_descriptions_to_schema(self, schema, descriptions):
+        """
+        Call the add_descriptions_to_schema function.
+
+        Args:
+            schema (dict): Schema to add descriptions to.
+            descriptions (dict): Descriptions to add.
+
+        Returns:
+            dict: Status and updated schema.
+        """
+        try:
+            updated_schema = add_descriptions_to_schema(schema, descriptions)
+            return {"status": "success", "updated_schema": updated_schema}
+        except Exception as e:
+            return {"status": "error", "message": f"Failed to add descriptions to schema: {str(e)}"}
+
+    def call_generate_schema(self, config):
+        """
+        Call the generate_schema function.
+
+        Args:
+            config (dict): Configuration for schema generation.
+
+        Returns:
+            dict: Status and generated schema.
+        """
+        try:
+            schema = generate_schema(config)
+            return {"status": "success", "schema": schema}
+        except Exception as e:
+            return {"status": "error", "message": f"Failed to generate schema: {str(e)}"}
+
+    def call_generate_schema_main(self, args):
+        """
+        Call the main function of generate_schema module.
+
+        Args:
+            args (list): Arguments for the main function.
+
+        Returns:
+            dict: Status of the operation.
+        """
+        try:
+            generate_schema_main(args)
+            return {"status": "success"}
+        except Exception as e:
+            return {"status": "error", "message": f"Failed to execute generate_schema main: {str(e)}"}
+
+    # -------------------- My App Utilities --------------------
+
+    def create_my_context_middleware(self):
+        """
+        Create an instance of MyContextMiddleware.
+
+        Returns:
+            dict: Status and instance of MyContextMiddleware.
+        """
+        try:
+            instance = MyContextMiddleware()
+            return {"status": "success", "instance": instance}
+        except Exception as e:
+            return {"status": "error", "message": f"Failed to create MyContextMiddleware: {str(e)}"}
+
+    # -------------------- Agent Utilities --------------------
+
+    def create_agent_state(self):
+        """
+        Create an instance of AgentState.
+
+        Returns:
+            dict: Status and instance of AgentState.
+        """
+        try:
+            instance = AgentState()
+            return {"status": "success", "instance": instance}
+        except Exception as e:
+            return {"status": "error", "message": f"Failed to create AgentState: {str(e)}"}
+
+    def create_context_schema(self):
+        """
+        Create an instance of ContextSchema.
+
+        Returns:
+            dict: Status and instance of ContextSchema.
+        """
+        try:
+            instance = ContextSchema()
+            return {"status": "success", "instance": instance}
+        except Exception as e:
+            return {"status": "error", "message": f"Failed to create ContextSchema: {str(e)}"}
+
+    def call_call_model(self, model_input):
+        """
+        Call the call_model function.
+
+        Args:
+            model_input (dict): Input for the model.
+
+        Returns:
+            dict: Status and model output.
+        """
+        try:
+            output = call_model(model_input)
+            return {"status": "success", "output": output}
+        except Exception as e:
+            return {"status": "error", "message": f"Failed to call model: {str(e)}"}
+
+    def call_should_continue(self, state):
+        """
+        Call the should_continue function.
+
+        Args:
+            state (AgentState): Current state of the agent.
+
+        Returns:
+            dict: Status and decision to continue.
+        """
+        try:
+            decision = should_continue(state)
+            return {"status": "success", "decision": decision}
+        except Exception as e:
+            return {"status": "error", "message": f"Failed to determine continuation: {str(e)}"}
+
+# End of Adapter class definition

langgraph/mcp_output/mcp_plugin/main.py

@@ -0,0 +1,13 @@
+"""
+MCP Service Auto-Wrapper - Auto-generated
+"""
+from mcp_service import create_app
+
+def main():
+    """Main entry point"""
+    app = create_app()
+    return app
+
+if __name__ == "__main__":
+    app = main()
+    app.run()

langgraph/mcp_output/mcp_plugin/mcp_service.py

@@ -0,0 +1,87 @@
+from fastmcp import FastMCP, subprocess, ctypes
+
+class CppServiceWrapper:
+    def __init__(self, executable_path):
+        self.executable_path = executable_path
+
+    def call_executable(self, *args):
+        try:
+            result = subprocess.run([self.executable_path] + list(args), capture_output=True, text=True)
+            if result.returncode != 0:
+                return {"success": False, "error": result.stderr}
+            return {"success": True, "result": result.stdout}
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+
+    def load_dynamic_library(self, lib_path):
+        try:
+            return ctypes.CDLL(lib_path)
+        except OSError as e:
+            return None
+
+def compile_project(build_system, source_dir):
+    try:
+        if build_system == "cmake":
+            subprocess.run(["cmake", source_dir], check=True)
+            subprocess.run(["make"], check=True)
+        elif build_system == "make":
+            subprocess.run(["make", "-C", source_dir], check=True)
+        elif build_system == "configure":
+            subprocess.run(["./configure"], cwd=source_dir, check=True)
+            subprocess.run(["make"], cwd=source_dir, check=True)
+        else:
+            return {"success": False, "error": "Unsupported build system"}
+        return {"success": True}
+    except subprocess.CalledProcessError as e:
+        return {"success": False, "error": str(e)}
+
+mcp = FastMCP("cpp_service")
+
+@ mcp.tool(name="compile_project", description="Compile the C/C++ project using the specified build system.")
+def compile_project_tool(build_system: str, source_dir: str) -> dict:
+    """
+    Compile the C/C++ project using the specified build system.
+
+    Parameters:
+    - build_system (str): The build system to use (e.g., 'cmake', 'make', 'configure').
+    - source_dir (str): The directory containing the source code.
+
+    Returns:
+    - dict: A dictionary containing 'success' and 'error' fields.
+    """
+    return compile_project(build_system, source_dir)
+
+@ mcp.tool(name="execute_cpp_function", description="Execute a C++ function via the compiled executable.")
+def execute_cpp_function(executable_path: str, *args: str) -> dict:
+    """
+    Execute a C++ function via the compiled executable.
+
+    Parameters:
+    - executable_path (str): Path to the compiled executable.
+    - args (str): Arguments to pass to the executable.
+
+    Returns:
+    - dict: A dictionary containing 'success', 'result', and 'error' fields.
+    """
+    wrapper = CppServiceWrapper(executable_path)
+    return wrapper.call_executable(*args)
+
+@ mcp.tool(name="load_cpp_library", description="Load a C++ dynamic library and return its handle.")
+def load_cpp_library(lib_path: str) -> dict:
+    """
+    Load a C++ dynamic library and return its handle.
+
+    Parameters:
+    - lib_path (str): Path to the dynamic library.
+
+    Returns:
+    - dict: A dictionary containing 'success' and 'result' fields.
+    """
+    wrapper = CppServiceWrapper("")
+    lib = wrapper.load_dynamic_library(lib_path)
+    if lib is None:
+        return {"success": False, "error": "Failed to load library"}
+    return {"success": True, "result": "Library loaded successfully"}
+
+def create_app():
+    return mcp

langgraph/mcp_output/requirements.txt

@@ -0,0 +1,6 @@
+fastmcp
+fastapi
+uvicorn[standard]
+pydantic>=2.0.0
+aiohttp
+sqlalchemy

langgraph/mcp_output/start_mcp.py

@@ -0,0 +1,30 @@
+
+"""
+MCP Service Startup Entry
+"""
+import sys
+import os
+
+project_root = os.path.dirname(os.path.abspath(__file__))
+mcp_plugin_dir = os.path.join(project_root, "mcp_plugin")
+if mcp_plugin_dir not in sys.path:
+    sys.path.insert(0, mcp_plugin_dir)
+
+from mcp_service import create_app
+
+def main():
+    """Start FastMCP service"""
+    app = create_app()
+    # Use environment variable to configure port, default 8000
+    port = int(os.environ.get("MCP_PORT", "8000"))
+    
+    # Choose transport mode based on environment variable
+    transport = os.environ.get("MCP_TRANSPORT", "stdio")
+    if transport == "http":
+        app.run(transport="http", host="0.0.0.0", port=port)
+    else:
+        # Default to STDIO mode
+        app.run()
+
+if __name__ == "__main__":
+    main()

langgraph/mcp_output/workflow_summary.json

@@ -0,0 +1,183 @@
+{
+  "repository": {
+    "name": "langgraph",
+    "url": "https://github.com/langchain-ai/langgraph",
+    "local_path": "/export/zxcpu1/shiweijie/code/ghh/Code2MCP/workspace/langgraph",
+    "description": "Python library",
+    "features": "Basic functionality",
+    "tech_stack": "Python",
+    "stars": 0,
+    "forks": 0,
+    "language": "Python",
+    "last_updated": "",
+    "complexity": "complex",
+    "intrusiveness_risk": "medium"
+  },
+  "execution": {
+    "start_time": 1770446493.10833,
+    "end_time": 1770446615.1185443,
+    "duration": 122.01021456718445,
+    "status": "success",
+    "workflow_status": "success",
+    "nodes_executed": [
+      "download",
+      "analysis",
+      "env",
+      "generate",
+      "run",
+      "review",
+      "finalize"
+    ],
+    "total_files_processed": 0,
+    "environment_type": "unknown",
+    "llm_calls": 0,
+    "deepwiki_calls": 0
+  },
+  "tests": {
+    "original_project": {
+      "passed": false,
+      "details": {},
+      "test_coverage": "100%",
+      "execution_time": 0,
+      "test_files": []
+    },
+    "mcp_plugin": {
+      "passed": true,
+      "details": {},
+      "service_health": "healthy",
+      "startup_time": 0,
+      "transport_mode": "stdio",
+      "fastmcp_version": "unknown",
+      "mcp_version": "unknown"
+    }
+  },
+  "analysis": {
+    "structure": {
+      "packages": []
+    },
+    "dependencies": {
+      "has_environment_yml": false,
+      "has_requirements_txt": false,
+      "pyproject": false,
+      "setup_cfg": false,
+      "setup_py": false
+    },
+    "entry_points": {
+      "imports": [],
+      "cli": [],
+      "modules": []
+    },
+    "risk_assessment": {
+      "import_feasibility": 0.8,
+      "intrusiveness_risk": "medium",
+      "complexity": "complex"
+    },
+    "deepwiki_analysis": {
+      "repo_url": "https://github.com/langchain-ai/langgraph",
+      "repo_name": "langgraph",
+      "content": "langchain-ai/langgraph\nPackage Structure and Dependencies\nCore Execution System\nStateGraph API\nFunctional API (@task and @entrypoint)\nPregel Execution Engine\nState Management and Channels\nControl Flow Primitives\nGraph Composition and Nested Graphs\nHuman-in-the-Loop and Interrupts\nError Handling and Retry Policies\nCaching System\nPersistence and Memory\nCheckpointing Architecture\nCheckpoint Implementations\nStore System\nSerialization\nTime Travel and State Forking\nClient SDKs and Remote Execution\nJavaScript/TypeScript SDK\nHTTP Client and Streaming\nAuthentication and Authorization\nData Models and Schemas\nRemoteGraph\nCLI and Deployment\nCLI Commands\nConfiguration System (langgraph.json)\nDocker Image Generation\nMulti-Service Orchestration\nLocal Development Server\nLangGraph API Surface\nAssistants and Versioning\nThreads and State Management\nRuns and Execution\nStreaming and Events\nPrebuilt Components\nReAct Agent (create_react_agent)\nToolNode and Tool Execution\nUI Integration\nDevelopment Infrastructure\nMonorepo Structure and Build System\nTesting Infrastructure\nCI/CD Workflows\nRelease Process\nlibs/checkpoint-postgres/pyproject.toml\nlibs/checkpoint-postgres/uv.lock\nlibs/checkpoint-sqlite/pyproject.toml\nlibs/checkpoint-sqlite/uv.lock\nlibs/checkpoint/pyproject.toml\nlibs/checkpoint/uv.lock\nlibs/langgraph/README.md\nlibs/langgraph/pyproject.toml\nlibs/langgraph/uv.lock\nlibs/prebuilt/pyproject.toml\nlibs/prebuilt/uv.lock\nPurpose and Scope\nLangGraph is a framework for building stateful, multi-actor applications with Large Language Models (LLMs). It provides low-level orchestration infrastructure for long-running, durable workflows without abstracting prompts or architecture. This page provides a high-level overview of LangGraph's architecture, core components, and execution model.\nFor detailed information on specific subsystems:\nPackage organization and dependencies: seePackage Structure and Dependencies\nGraph building and execution: seeCore Execution System\nState persistence: seePersistence and Memory\nRemote deployment: seeClient SDKs and Remote Execution\nDevelopment tools: seeCLI and Deployment\nSources:README.md1-92libs/langgraph/README.md1-92libs/langgraph/pyproject.toml1-129\nCore Concepts\nLangGraph implements aBulk Synchronous Parallel (BSP)execution model inspired by Google's Pregel. The framework centers on three foundational abstractions:\nMessageGraph\nBaseCheckpointSaver\nApplications define graphs declaratively using theStateGraphAPI or imperatively using the@entrypoint/@taskfunctional API. At runtime, thePregelengine orchestrates execution in discrete steps, persisting checkpoints after each step for durability and time-travel debugging.\n@entrypoint\nSources:README.md59-67libs/langgraph/pyproject.toml6-8\nArchitectural Components\nThe LangGraph system comprises six major subsystems that work together to enable stateful agent workflows:\n6. API Server5. SDK Layer4. Development Tools3. Prebuilt Components2. Persistence Layer1. Core Frameworkcompiles tocreatespersists viausesimplementsimplementsimplementsusesusesgeneratesopensconnects toconnects torunsusesStateGraph(graph builder API)@entrypoint / @task(functional API)Pregel(execution engine)BaseCheckpointSaver(checkpoint interface)PostgresCheckpointSaverSqliteCheckpointSaverInMemoryCheckpointSaverBaseStore(cross-thread memory)create_react_agent()ToolNode(tool execution)langgraph CLILangGraph StudioLangGraphClient(Python SDK)@langchain/langgraph-sdk(JavaScript SDK)langgraph-api(FastAPI server)\ncompiles to\npersists via\nconnects to\nconnects to\nStateGraph(graph builder API)\n@entrypoint / @task(functional API)\nPregel(execution engine)\nBaseCheckpointSaver(checkpoint interface)\nPostgresCheckpointSaver\nSqliteCheckpointSaver\nInMemoryCheckpointSaver\nBaseStore(cross-thread memory)\ncreate_react_agent()\nToolNode(tool execution)\nlanggraph CLI\nLangGraph Studio\nLangGraphClient(Python SDK)\n@langchain/langgraph-sdk(JavaScript SDK)\nlanggraph-api(FastAPI server)\nComponent Descriptions:\nCore Framework: TheStateGraphclass (libs/langgraph/langgraph/graph/state.py) provides methods likeadd_node(),add_edge(), andcompile()to build graphs. ThePregelclass (libs/langgraph/langgraph/pregel/__init__.py) executes graphs in BSP steps. The functional API (libs/langgraph/langgraph/func/__init__.py) offers@entrypointand@taskdecorators for simpler graph construction.\nCore Framework: TheStateGraphclass (libs/langgraph/langgraph/graph/state.py) provides methods likeadd_node(),add_edge(), andcompile()to build graphs. ThePregelclass (libs/langgraph/langgraph/pregel/__init__.py) executes graphs in BSP steps. The functional API (libs/langgraph/langgraph/func/__init__.py) offers@entrypointand@taskdecorators for simpler graph construction.\n@entrypoint\nPersistence Layer:BaseCheckpointSaver(libs/checkpoint/langgraph/checkpoint/base/__init__.py) defines the interface for checkpoint persistence. Implementations includePostgresCheckpointSaver(libs/checkpoint-postgres/) for production deployments andSqliteCheckpointSaver(libs/checkpoint-sqlite/) for local development.BaseStore(libs/checkpoint/langgraph/checkpoint/store/base.py) provides cross-thread memory for long-term agent context.\nPersistence Layer:BaseCheckpointSaver(libs/checkpoint/langgraph/checkpoint/base/__init__.py) defines the interface for checkpoint persistence. Implementations includePostgresCheckpointSaver(libs/checkpoint-postgres/) for production deployments andSqliteCheckpointSaver(libs/checkpoint-sqlite/) for local development.BaseStore(libs/checkpoint/langgraph/checkpoint/store/base.py) provides cross-thread memory for long-term agent context.\nBaseCheckpointSaver\nPostgresCheckpointSaver\nSqliteCheckpointSaver\nPrebuilt Components: Thecreate_react_agent()function (libs/prebuilt/langgraph/prebuilt/chat_agent_executor.py) constructs a ReAct-style agent graph.ToolNode(libs/prebuilt/langgraph/prebuilt/tool_node.py) handles tool invocation with automatic error handling.\nPrebuilt Components: Thecreate_react_agent()function (libs/prebuilt/langgraph/prebuilt/chat_agent_executor.py) constructs a ReAct-style agent graph.ToolNode(libs/prebuilt/langgraph/prebuilt/tool_node.py) handles tool invocation with automatic error handling.\ncreate_react_agent()\nDevelopment Tools: ThelanggraphCLI (libs/cli/) provides commands likedev,build, andupfor local development and Docker image generation. LangGraph Studio is a visual debugging interface.\nDevelopment Tools: ThelanggraphCLI (libs/cli/) provides commands likedev,build, andupfor local development and Docker image generation. LangGraph Studio is a visual debugging interface.\nSDK Layer:LangGraphClient(libs/sdk-py/) enables Python applications to interact with remote LangGraph deployments. The JavaScript SDK (libs/sdk-js/) provides similar functionality with React hooks for streaming.\nSDK Layer:LangGraphClient(libs/sdk-py/) enables Python applications to interact with remote LangGraph deployments. The JavaScript SDK (libs/sdk-js/) provides similar functionality with React hooks for streaming.\nLangGraphClient\nAPI Server: Thelanggraph-apipackage (libs/api-service/) exposes deployed graphs via a REST API with Server-Sent Events (SSE) streaming.\nAPI Server: Thelanggraph-apipackage (libs/api-service/) exposes deployed graphs via a REST API with Server-Sent Events (SSE) streaming.\nlanggraph-api\nSources:libs/langgraph/pyproject.toml26-33libs/checkpoint/pyproject.toml14-17libs/checkpoint-postgres/pyproject.toml14-19libs/checkpoint-sqlite/pyproject.toml14-18libs/prebuilt/pyproject.toml26-29\nPackage Ecosystem\nLangGraph is distributed as multiple PyPI packages with explicit dependency relationships:\nlanggraphv1.0.7langgraph-checkpointv4.0.0langgraph-checkpoint-postgresv3.0.4langgraph-checkpoint-sqlitev3.0.3langgraph-prebuiltv1.0.7langgraph-sdkv0.3.xlanggraph-clilangchain-core>=0.1pydantic>=2.7.4ormsgpack>=1.12.0psycopg>=3.2.0aiosqlite>=0.20\nlanggraphv1.0.7\nlanggraph-checkpointv4.0.0\nlanggraph-checkpoint-postgresv3.0.4\nlanggraph-checkpoint-sqlitev3.0.3\nlanggraph-prebuiltv1.0.7\nlanggraph-sdkv0.3.x\nlanggraph-cli\nlangchain-core>=0.1\npydantic>=2.7.4\normsgpack>=1.12.0\npsycopg>=3.2.0\naiosqlite>=0.20\nPackage Descriptions:\nlanggraph-checkpoint>=2.1.0\nlangchain-core>=0.1\npydantic>=2.7.4\nlanggraph-checkpoint\nlangchain-core>=0.2.38\normsgpack>=1.12.0\nlanggraph-checkpoint-postgres\nlanggraph-checkpoint>=2.1.2\npsycopg>=3.2.0\nlanggraph-checkpoint-sqlite\nlanggraph-checkpoint>=3\naiosqlite>=0.20\nlanggraph-prebuilt\nlanggraph-checkpoint>=2.1.0\nlangchain-core>=1.0.0\nlanggraph-sdk\nlanggraph-cli\nlanggraph-sdk\nThe modular design allows users to install only required components. For example, a production deployment might uselanggraph+langgraph-checkpoint-postgres, while local development useslanggraph+langgraph-checkpoint-sqlite.\nlanggraph-checkpoint-postgres\nlanggraph-checkpoint-sqlite\nSources:libs/langgraph/pyproject.toml26-33libs/checkpoint/pyproject.toml14-17libs/checkpoint-postgres/pyproject.toml14-19libs/checkpoint-sqlite/pyproject.toml14-18libs/prebuilt/pyproject.toml26-29\nExecution Model\nLangGraph implements a Bulk Synchronous Parallel (BSP) execution model with automatic checkpointing:\nNodePregelRunnerPregelAlgoPregelLoopCheckpointerCompiledGraphNode[\"Node Function\"]Checkpointer[\"BaseCheckpointSaver\"]PregelRunner[\"PregelRunner\"]PregelAlgo[\"PregelAlgo\"]PregelLoop[\"PregelLoop\"]CompiledGraph[\"CompiledStateGraph\"]UserNodePregelRunnerPregelAlgoPregelLoopCheckpointerCompiledGraphNode[\"Node Function\"]Checkpointer[\"BaseCheckpointSaver\"]PregelRunner[\"PregelRunner\"]PregelAlgo[\"PregelAlgo\"]PregelLoop[\"PregelLoop\"]CompiledGraph[\"CompiledStateGraph\"]Userpar[Parallel Execution]alt[Interrupt]loop[BSP Steps]invoke(input, config)load checkpoint (or create new)CheckpointTupleexecute stepprepare_next_tasks()tasks listexecute tasks in parallelcall node_a(state)call node_b(state)node outputstask resultsupdate channels with outputsput checkpoint (checkpoint_ns, checkpoint)GraphInterrupt exceptionfinal state\nKey Execution Characteristics:\nStep-based Execution: ThePregelLoop(libs/langgraph/langgraph/pregel/loop.py) orchestrates execution in discrete supersteps. Each step consists of:Planning:PregelAlgodetermines which nodes can execute based on channel statesExecution:PregelRunnerinvokes node functions in parallelUpdate: Results are written to channelsCheckpoint: State is persisted viaBaseCheckpointSaver\nStep-based Execution: ThePregelLoop(libs/langgraph/langgraph/pregel/loop.py) orchestrates execution in discrete supersteps. Each step consists of:\nPlanning:PregelAlgodetermines which nodes can execute based on channel states\nExecution:PregelRunnerinvokes node functions in parallel\nPregelRunner\nUpdate: Results are written to channels\nCheckpoint: State is persisted viaBaseCheckpointSaver\nBaseCheckpointSaver\nChannel System: State flows between nodes through typed channels (libs/langgraph/langgraph/channels/). Channel types include:LastValue: Overwrites previous valueTopic: Appends to a sequenceBinaryOperatorAggregate: Combines values with a reducer functionEphemeralValue: Not persisted in checkpoints\nChannel System: State flows between nodes through typed channels (libs/langgraph/langgraph/channels/). Channel types include:\nLastValue: Overwrites previous value\nTopic: Appends to a sequence\nBinaryOperatorAggregate: Combines values with a reducer function\nBinaryOperatorAggregate\nEphemeralValue: Not persisted in checkpoints\nEphemeralValue\nDurability Modes: Configured viacompile()withinterrupt_before/interrupt_afteror explicitCommand.update()/Command.goto()returns. The system automatically saves checkpoints according to the durability policy.\nDurability Modes: Configured viacompile()withinterrupt_before/interrupt_afteror explicitCommand.update()/Command.goto()returns. The system automatically saves checkpoints according to the durability policy.\ninterrupt_before\ninterrupt_after\nCommand.update()\nCommand.goto()\nResumability: Any checkpoint can be loaded and execution resumed from that point usinginvoke(input, config={\"configurable\": {\"checkpoint_id\": \"...\"}}).\nResumability: Any checkpoint can be loaded and execution resumed from that point usinginvoke(input, config={\"configurable\": {\"checkpoint_id\": \"...\"}}).\ninvoke(input, config={\"configurable\": {\"checkpoint_id\": \"...\"}})\nSources:libs/langgraph/langgraph/pregel/__init__.pylibs/langgraph/langgraph/pregel/loop.pylibs/langgraph/langgraph/channels/\nDevelopment Workflow\nThe typical LangGraph development lifecycle progresses from local iteration to production deployment:\niterateopenreadytest locallydeployLocal Development(in-memory execution)langgraph dev(hot-reload server)LangGraph Studio(visual debugger)langgraph build(Docker image)docker compose up(PostgreSQL + Redis + API)LangSmith Deployment(managed hosting)SDK Access(LangGraphClient)\ntest locally\nLocal Development(in-memory execution)\nlanggraph dev(hot-reload server)\nLangGraph Studio(visual debugger)\nlanggraph build(Docker image)\ndocker compose up(PostgreSQL + Redis + API)\nLangSmith Deployment(managed hosting)\nSDK Access(LangGraphClient)\nWorkflow Stages:\nLocal Development: Write graph code and test withStateGraph.compile().invoke(). UseInMemoryCheckpointSaver(libs/checkpoint/langgraph/checkpoint/memory/__init__.py) for fast iteration without external dependencies.\nLocal Development: Write graph code and test withStateGraph.compile().invoke(). UseInMemoryCheckpointSaver(libs/checkpoint/langgraph/checkpoint/memory/__init__.py) for fast iteration without external dependencies.\nStateGraph.compile().invoke()\nInMemoryCheckpointSaver\nDevelopment Server: Runlanggraph dev(libs/cli/langgraph_cli/cli.py) to start a local server with hot reloading. The server automatically reloads on code changes and exposes the graph athttp://localhost:8123.\nDevelopment Server: Runlanggraph dev(libs/cli/langgraph_cli/cli.py) to start a local server with hot reloading. The server automatically reloads on code changes and exposes the graph athttp://localhost:8123.",
+      "model": "gpt-4o-2024-08-06",
+      "source": "selenium",
+      "success": true
+    },
+    "code_complexity": {
+      "cyclomatic_complexity": "medium",
+      "cognitive_complexity": "medium",
+      "maintainability_index": 75
+    },
+    "security_analysis": {
+      "vulnerabilities_found": 0,
+      "security_score": 85,
+      "recommendations": []
+    }
+  },
+  "plugin_generation": {
+    "files_created": [
+      "mcp_output/start_mcp.py",
+      "mcp_output/mcp_plugin/__init__.py",
+      "mcp_output/mcp_plugin/mcp_service.py",
+      "mcp_output/mcp_plugin/adapter.py",
+      "mcp_output/mcp_plugin/main.py",
+      "mcp_output/requirements.txt",
+      "mcp_output/README_MCP.md"
+    ],
+    "main_entry": "start_mcp.py",
+    "requirements": [
+      "fastmcp>=0.1.0",
+      "pydantic>=2.0.0"
+    ],
+    "readme_path": "/export/zxcpu1/shiweijie/code/ghh/Code2MCP/workspace/langgraph/mcp_output/README_MCP.md",
+    "adapter_mode": "import",
+    "total_lines_of_code": 0,
+    "generated_files_size": 0,
+    "tool_endpoints": 0,
+    "supported_features": [
+      "Basic functionality"
+    ],
+    "generated_tools": [
+      "Basic tools",
+      "Health check tools",
+      "Version info tools"
+    ]
+  },
+  "code_review": {},
+  "errors": [],
+  "warnings": [],
+  "recommendations": [
+    "- Implement comprehensive test coverage to ensure code reliability and maintainability\n- Optimize large file sizes to improve performance and reduce load times\n- Enhance documentation for better understanding of complex modules and functions\n- Streamline the dependency management process by utilizing a requirements.txt or pyproject.toml file\n- Improve the CI/CD workflows to automate testing and deployment processes\n- Refactor code to reduce complexity and improve readability\n- Conduct a security audit to identify and mitigate potential vulnerabilities\n- Enhance the CLI tool with more user-friendly commands and options\n- Implement a more robust error handling mechanism to improve system resilience\n- Optimize the use of resources in the development and production environments\n- Increase the modularity of the codebase to facilitate easier updates and maintenance\n- Improve the integration of the JavaScript/TypeScript SDK with the existing system\n- Enhance the caching system to improve data retrieval speeds\n- Conduct regular performance testing to identify and address bottlenecks\n- Improve the logging and monitoring systems for better issue tracking and resolution"
+  ],
+  "performance_metrics": {
+    "memory_usage_mb": 0,
+    "cpu_usage_percent": 0,
+    "response_time_ms": 0,
+    "throughput_requests_per_second": 0
+  },
+  "deployment_info": {
+    "supported_platforms": [
+      "Linux",
+      "Windows",
+      "macOS"
+    ],
+    "python_versions": [
+      "3.8",
+      "3.9",
+      "3.10",
+      "3.11",
+      "3.12"
+    ],
+    "deployment_methods": [
+      "Docker",
+      "pip",
+      "conda"
+    ],
+    "monitoring_support": true,
+    "logging_configuration": "structured"
+  },
+  "execution_analysis": {
+    "success_factors": [
+      "Efficient execution of all workflow nodes",
+      "Successful generation of MCP plugin files"
+    ],
+    "failure_reasons": [],
+    "overall_assessment": "good",
+    "node_performance": {
+      "download_time": "Completed successfully, indicating efficient data retrieval",
+      "analysis_time": "Completed successfully, indicating effective code analysis",
+      "generation_time": "Completed successfully, indicating efficient code generation",
+      "test_time": "No original project tests passed, indicating potential issues with test setup or coverage"
+    },
+    "resource_usage": {
+      "memory_efficiency": "Memory usage data not available",
+      "cpu_efficiency": "CPU usage data not available",
+      "disk_usage": "Disk usage data not available"
+    }
+  },
+  "technical_quality": {
+    "code_quality_score": 70,
+    "architecture_score": 75,
+    "performance_score": 65,
+    "maintainability_score": 75,
+    "security_score": 85,
+    "scalability_score": 70
+  }
+}

langgraph/source/AGENTS.md

@@ -0,0 +1,57 @@
+# AGENTS Instructions
+
+This repository is a monorepo. Each library lives in a subdirectory under `libs/`.
+
+When you modify code in any library, run the following commands in that library's directory before creating a pull request:
+
+- `make format` – run code formatters
+- `make lint` – run the linter
+- `make test` – execute the test suite
+
+To run a particular test file or to pass additional pytest options you can specify the `TEST` variable:
+
+```txt
+TEST=path/to/test.py make test
+```
+
+Other pytest arguments can also be supplied inside the `TEST` variable.
+
+## Libraries
+
+The repository contains several Python and JavaScript/TypeScript libraries.
+Below is a high-level overview:
+
+- **checkpoint** – base interfaces for LangGraph checkpointers.
+- **checkpoint-postgres** – Postgres implementation of the checkpoint saver.
+- **checkpoint-sqlite** – SQLite implementation of the checkpoint saver.
+- **cli** – official command-line interface for LangGraph.
+- **langgraph** – core framework for building stateful, multi-actor agents.
+- **prebuilt** – high-level APIs for creating and running agents and tools.
+- **sdk-js** – JS/TS SDK for interacting with the LangGraph REST API.
+- **sdk-py** – Python SDK for the LangGraph Server API.
+
+### Dependency map
+
+The diagram below lists downstream libraries for each production dependency as
+declared in that library's `pyproject.toml` (or `package.json`).
+
+```text
+checkpoint
+├── checkpoint-postgres
+├── checkpoint-sqlite
+├── prebuilt
+└── langgraph
+
+prebuilt
+└── langgraph
+
+sdk-py
+├── langgraph
+└── cli
+
+sdk-js (standalone)
+```
+
+Changes to a library may impact all of its dependents shown above.
+
+- Do NOT use Sphinx-style double backtick formatting (` ``code`` `). Use single backticks (`` `code` ``) for inline code references in docstrings and comments.

langgraph/source/CLAUDE.md

@@ -0,0 +1,57 @@
+# AGENTS Instructions
+
+This repository is a monorepo. Each library lives in a subdirectory under `libs/`.
+
+When you modify code in any library, run the following commands in that library's directory before creating a pull request:
+
+- `make format` – run code formatters
+- `make lint` – run the linter
+- `make test` – execute the test suite
+
+To run a particular test file or to pass additional pytest options you can specify the `TEST` variable:
+
+```
+TEST=path/to/test.py make test
+```
+
+Other pytest arguments can also be supplied inside the `TEST` variable.
+
+## Libraries
+
+The repository contains several Python and JavaScript/TypeScript libraries.
+Below is a high-level overview:
+
+- **checkpoint** – base interfaces for LangGraph checkpointers.
+- **checkpoint-postgres** – Postgres implementation of the checkpoint saver.
+- **checkpoint-sqlite** – SQLite implementation of the checkpoint saver.
+- **cli** – official command-line interface for LangGraph.
+- **langgraph** – core framework for building stateful, multi-actor agents.
+- **prebuilt** – high-level APIs for creating and running agents and tools.
+- **sdk-js** – JS/TS SDK for interacting with the LangGraph REST API.
+- **sdk-py** – Python SDK for the LangGraph Server API.
+
+### Dependency map
+
+The diagram below lists downstream libraries for each production dependency as
+declared in that library's `pyproject.toml` (or `package.json`).
+
+```text
+checkpoint
+├── checkpoint-postgres
+├── checkpoint-sqlite
+├── prebuilt
+└── langgraph
+
+prebuilt
+└── langgraph
+
+sdk-py
+├── langgraph
+└── cli
+
+sdk-js (standalone)
+```
+
+Changes to a library may impact all of its dependents shown above.
+
+- Do NOT use Sphinx-style double backtick formatting (` ``code`` `). Use single backticks (`` `code` ``) for inline code references in docstrings and comments.

langgraph/source/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 LangChain, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

langgraph/source/Makefile

@@ -0,0 +1,68 @@
+# Define the directories containing projects
+LIBS_DIRS := $(wildcard libs/*)
+
+# Default target
+.PHONY: all
+all: lint format lock test
+
+# Install dependencies for all projects
+.PHONY: install
+install:
+	@echo "Creating virtual environment..."
+	@uv venv
+	@for dir in $(LIBS_DIRS); do \
+		if [ -f $$dir/pyproject.toml ]; then \
+			echo "Installing dependencies for $$dir"; \
+			uv pip install -e $$dir; \
+		fi; \
+	done
+
+# Lint all projects
+.PHONY: lint
+lint:
+	@for dir in $(LIBS_DIRS); do \
+		if [ -f $$dir/Makefile ]; then \
+			echo "Running lint in $$dir"; \
+			$(MAKE) -C $$dir lint; \
+		fi; \
+	done
+
+# Format all projects
+.PHONY: format
+format:
+	@for dir in $(LIBS_DIRS); do \
+		if [ -f $$dir/Makefile ]; then \
+			echo "Running format in $$dir"; \
+			$(MAKE) -C $$dir format; \
+		fi; \
+	done
+
+# Lock all projects
+.PHONY: lock
+lock:
+	@for dir in $(LIBS_DIRS); do \
+		if [ -f $$dir/Makefile ]; then \
+			echo "Running lock in $$dir"; \
+			(cd $$dir && uv lock); \
+		fi; \
+	done
+
+# Lock all projects and upgrade dependencies
+.PHONY: lock-upgrade
+lock-upgrade:
+	@for dir in $(LIBS_DIRS); do \
+		if [ -f $$dir/Makefile ]; then \
+			echo "Running lock-upgrade in $$dir"; \
+			(cd $$dir && uv lock --upgrade); \
+		fi; \
+	done
+
+# Test all projects
+.PHONY: test
+test:
+	@for dir in $(LIBS_DIRS); do \
+		if [ -f $$dir/Makefile ]; then \
+			echo "Running test in $$dir"; \
+			$(MAKE) -C $$dir test; \
+		fi; \
+	done

langgraph/source/README.md

@@ -0,0 +1,91 @@
+<picture class="github-only">
+  <source media="(prefers-color-scheme: light)" srcset="https://langchain-ai.github.io/langgraph/static/wordmark_dark.svg">
+  <source media="(prefers-color-scheme: dark)" srcset="https://langchain-ai.github.io/langgraph/static/wordmark_light.svg">
+  <img alt="LangGraph Logo" src="https://langchain-ai.github.io/langgraph/static/wordmark_dark.svg" width="80%">
+</picture>
+
+<div>
+<br>
+</div>
+
+[![Version](https://img.shields.io/pypi/v/langgraph.svg)](https://pypi.org/project/langgraph/)
+[![Downloads](https://static.pepy.tech/badge/langgraph/month)](https://pepy.tech/project/langgraph)
+[![Open Issues](https://img.shields.io/github/issues-raw/langchain-ai/langgraph)](https://github.com/langchain-ai/langgraph/issues)
+[![Docs](https://img.shields.io/badge/docs-latest-blue)](https://docs.langchain.com/oss/python/langgraph/overview)
+
+Trusted by companies shaping the future of agents – including Klarna, Replit, Elastic, and more – LangGraph is a low-level orchestration framework for building, managing, and deploying long-running, stateful agents.
+
+## Get started
+
+Install LangGraph:
+
+```
+pip install -U langgraph
+```
+
+Create a simple workflow:
+
+```python
+from langgraph.graph import START, StateGraph
+from typing_extensions import TypedDict
+
+
+class State(TypedDict):
+    text: str
+
+
+def node_a(state: State) -> dict:
+    return {"text": state["text"] + "a"}
+
+
+def node_b(state: State) -> dict:
+    return {"text": state["text"] + "b"}
+
+
+graph = StateGraph(State)
+graph.add_node("node_a", node_a)
+graph.add_node("node_b", node_b)
+graph.add_edge(START, "node_a")
+graph.add_edge("node_a", "node_b")
+
+print(graph.compile().invoke({"text": ""}))
+# {'text': 'ab'}
+```
+
+Get started with the [LangGraph Quickstart](https://docs.langchain.com/oss/python/langgraph/quickstart).
+
+To quickly build agents with LangChain's `create_agent` (built on LangGraph), see the [LangChain Agents documentation](https://docs.langchain.com/oss/python/langchain/agents).
+
+## Core benefits
+
+LangGraph provides low-level supporting infrastructure for *any* long-running, stateful workflow or agent. LangGraph does not abstract prompts or architecture, and provides the following central benefits:
+
+- [Durable execution](https://docs.langchain.com/oss/python/langgraph/durable-execution): Build agents that persist through failures and can run for extended periods, automatically resuming from exactly where they left off.
+- [Human-in-the-loop](https://docs.langchain.com/oss/python/langgraph/interrupts): Seamlessly incorporate human oversight by inspecting and modifying agent state at any point during execution.
+- [Comprehensive memory](https://docs.langchain.com/oss/python/langgraph/memory): Create truly stateful agents with both short-term working memory for ongoing reasoning and long-term persistent memory across sessions.
+- [Debugging with LangSmith](http://www.langchain.com/langsmith): Gain deep visibility into complex agent behavior with visualization tools that trace execution paths, capture state transitions, and provide detailed runtime metrics.
+- [Production-ready deployment](https://docs.langchain.com/langsmith/app-development): Deploy sophisticated agent systems confidently with scalable infrastructure designed to handle the unique challenges of stateful, long-running workflows.
+
+## LangGraph’s ecosystem
+
+While LangGraph can be used standalone, it also integrates seamlessly with any LangChain product, giving developers a full suite of tools for building agents. To improve your LLM application development, pair LangGraph with:
+
+- [LangSmith](http://www.langchain.com/langsmith) — Helpful for agent evals and observability. Debug poor-performing LLM app runs, evaluate agent trajectories, gain visibility in production, and improve performance over time.
+- [LangSmith Deployment](https://docs.langchain.com/langsmith/deployments) — Deploy and scale agents effortlessly with a purpose-built deployment platform for long running, stateful workflows. Discover, reuse, configure, and share agents across teams — and iterate quickly with visual prototyping in [LangGraph Studio](https://docs.langchain.com/oss/python/langgraph/studio).
+- [LangChain](https://docs.langchain.com/oss/python/langchain/overview) – Provides integrations and composable components to streamline LLM application development.
+
+> [!NOTE]
+> Looking for the JS version of LangGraph? See the [JS repo](https://github.com/langchain-ai/langgraphjs) and the [JS docs](https://docs.langchain.com/oss/javascript/langgraph/overview).
+
+## Additional resources
+
+- [Guides](https://docs.langchain.com/oss/python/langgraph/overview): Quick, actionable code snippets for topics such as streaming, adding memory & persistence, and design patterns (e.g. branching, subgraphs, etc.).
+- [Reference](https://reference.langchain.com/python/langgraph/): Detailed reference on core classes, methods, how to use the graph and checkpointing APIs, and higher-level prebuilt components.
+- [Examples](https://docs.langchain.com/oss/python/langgraph/agentic-rag): Guided examples on getting started with LangGraph.
+- [LangChain Forum](https://forum.langchain.com/): Connect with the community and share all of your technical questions, ideas, and feedback.
+- [LangChain Academy](https://academy.langchain.com/courses/intro-to-langgraph): Learn the basics of LangGraph in our free, structured course.
+- [Case studies](https://www.langchain.com/built-with-langgraph): Hear how industry leaders use LangGraph to ship AI applications at scale.
+
+## Acknowledgements
+
+LangGraph is inspired by [Pregel](https://research.google/pubs/pub37252/) and [Apache Beam](https://beam.apache.org/). The public interface draws inspiration from [NetworkX](https://networkx.org/documentation/latest/). LangGraph is built by LangChain Inc, the creators of LangChain, but can be used without LangChain.

langgraph/source/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""
+langgraph Project Package Initialization File
+"""

langgraph/source/examples/README.md

@@ -0,0 +1,3 @@
+# LangGraph examples
+
+This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview). Please refer to the LangChain docs for the most up-to-date examples and usage guidelines for LangGraph.

langgraph/source/examples/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

langgraph/source/examples/chatbot-simulation-evaluation/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

langgraph/source/examples/chatbot-simulation-evaluation/agent-simulation-evaluation.ipynb

@@ -0,0 +1,41 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "10251c1c",
+   "metadata": {},
+   "source": [
+    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/tutorials/chatbot-simulation-evaluation/agent-simulation-evaluation.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c5fc63df",
+   "metadata": {},
+   "source": [
+    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

langgraph/source/examples/chatbot-simulation-evaluation/langsmith-agent-simulation-evaluation.ipynb

@@ -0,0 +1,41 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "a4351a24",
+   "metadata": {},
+   "source": [
+    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/tutorials/chatbot-simulation-evaluation/langsmith-agent-simulation-evaluation.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4cc9af1e",
+   "metadata": {},
+   "source": [
+    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

langgraph/source/examples/chatbot-simulation-evaluation/simulation_utils.py

@@ -0,0 +1,203 @@
+import functools
+from typing import Annotated, Any, Callable, Dict, List, Optional, Union
+
+from langchain_community.adapters.openai import convert_message_to_dict
+from langchain_core.messages import AIMessage, AnyMessage, BaseMessage, HumanMessage
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain_core.runnables import Runnable, RunnableLambda
+from langchain_core.runnables import chain as as_runnable
+from langchain_openai import ChatOpenAI
+from typing_extensions import TypedDict
+
+from langgraph.graph import END, StateGraph, START
+
+
+def langchain_to_openai_messages(messages: List[BaseMessage]):
+    """
+    Convert a list of langchain base messages to a list of openai messages.
+
+    Parameters:
+        messages (List[BaseMessage]): A list of langchain base messages.
+
+    Returns:
+        List[dict]: A list of openai messages.
+    """
+
+    return [
+        convert_message_to_dict(m) if isinstance(m, BaseMessage) else m
+        for m in messages
+    ]
+
+
+def create_simulated_user(
+    system_prompt: str, llm: Runnable | None = None
+) -> Runnable[Dict, AIMessage]:
+    """
+    Creates a simulated user for chatbot simulation.
+
+    Args:
+        system_prompt (str): The system prompt to be used by the simulated user.
+        llm (Runnable | None, optional): The language model to be used for the simulation.
+            Defaults to gpt-3.5-turbo.
+
+    Returns:
+        Runnable[Dict, AIMessage]: The simulated user for chatbot simulation.
+    """
+    return ChatPromptTemplate.from_messages(
+        [
+            ("system", system_prompt),
+            MessagesPlaceholder(variable_name="messages"),
+        ]
+    ) | (llm or ChatOpenAI(model="gpt-3.5-turbo")).with_config(
+        run_name="simulated_user"
+    )
+
+
+Messages = Union[list[AnyMessage], AnyMessage]
+
+
+def add_messages(left: Messages, right: Messages) -> Messages:
+    if not isinstance(left, list):
+        left = [left]
+    if not isinstance(right, list):
+        right = [right]
+    return left + right
+
+
+class SimulationState(TypedDict):
+    """
+    Represents the state of a simulation.
+
+    Attributes:
+        messages (List[AnyMessage]): A list of messages in the simulation.
+        inputs (Optional[dict[str, Any]]): Optional inputs for the simulation.
+    """
+
+    messages: Annotated[List[AnyMessage], add_messages]
+    inputs: Optional[dict[str, Any]]
+
+
+def create_chat_simulator(
+    assistant: (
+        Callable[[List[AnyMessage]], str | AIMessage]
+        | Runnable[List[AnyMessage], str | AIMessage]
+    ),
+    simulated_user: Runnable[Dict, AIMessage],
+    *,
+    input_key: str,
+    max_turns: int = 6,
+    should_continue: Optional[Callable[[SimulationState], str]] = None,
+):
+    """Creates a chat simulator for evaluating a chatbot.
+
+    Args:
+        assistant: The chatbot assistant function or runnable object.
+        simulated_user: The simulated user object.
+        input_key: The key for the input to the chat simulation.
+        max_turns: The maximum number of turns in the chat simulation. Default is 6.
+        should_continue: Optional function to determine if the simulation should continue.
+            If not provided, a default function will be used.
+
+    Returns:
+        The compiled chat simulation graph.
+
+    """
+    graph_builder = StateGraph(SimulationState)
+    graph_builder.add_node(
+        "user",
+        _create_simulated_user_node(simulated_user),
+    )
+    graph_builder.add_node(
+        "assistant", _fetch_messages | assistant | _coerce_to_message
+    )
+    graph_builder.add_edge("assistant", "user")
+    graph_builder.add_conditional_edges(
+        "user",
+        should_continue or functools.partial(_should_continue, max_turns=max_turns),
+    )
+    # If your dataset has a 'leading question/input', then we route first to the assistant, otherwise, we let the user take the lead.
+    graph_builder.add_edge(START, "assistant" if input_key is not None else "user")
+
+    return (
+        RunnableLambda(_prepare_example).bind(input_key=input_key)
+        | graph_builder.compile()
+    )
+
+
+## Private methods
+
+
+def _prepare_example(inputs: dict[str, Any], input_key: Optional[str] = None):
+    if input_key is not None:
+        if input_key not in inputs:
+            raise ValueError(
+                f"Dataset's example input must contain the provided input key: '{input_key}'.\nFound: {list(inputs.keys())}"
+            )
+        messages = [HumanMessage(content=inputs[input_key])]
+        return {
+            "inputs": {k: v for k, v in inputs.items() if k != input_key},
+            "messages": messages,
+        }
+    return {"inputs": inputs, "messages": []}
+
+
+def _invoke_simulated_user(state: SimulationState, simulated_user: Runnable):
+    """Invoke the simulated user node."""
+    runnable = (
+        simulated_user
+        if isinstance(simulated_user, Runnable)
+        else RunnableLambda(simulated_user)
+    )
+    inputs = state.get("inputs", {})
+    inputs["messages"] = state["messages"]
+    return runnable.invoke(inputs)
+
+
+def _swap_roles(state: SimulationState):
+    new_messages = []
+    for m in state["messages"]:
+        if isinstance(m, AIMessage):
+            new_messages.append(HumanMessage(content=m.content))
+        else:
+            new_messages.append(AIMessage(content=m.content))
+    return {
+        "inputs": state.get("inputs", {}),
+        "messages": new_messages,
+    }
+
+
+@as_runnable
+def _fetch_messages(state: SimulationState):
+    """Invoke the simulated user node."""
+    return state["messages"]
+
+
+def _convert_to_human_message(message: BaseMessage):
+    return {"messages": [HumanMessage(content=message.content)]}
+
+
+def _create_simulated_user_node(simulated_user: Runnable):
+    """Simulated user accepts a {"messages": [...]} argument and returns a single message."""
+    return (
+        _swap_roles
+        | RunnableLambda(_invoke_simulated_user).bind(simulated_user=simulated_user)
+        | _convert_to_human_message
+    )
+
+
+def _coerce_to_message(assistant_output: str | BaseMessage):
+    if isinstance(assistant_output, str):
+        return {"messages": [AIMessage(content=assistant_output)]}
+    else:
+        return {"messages": [assistant_output]}
+
+
+def _should_continue(state: SimulationState, max_turns: int = 6):
+    messages = state["messages"]
+    # TODO support other stop criteria
+    if len(messages) > max_turns:
+        return END
+    elif messages[-1].content.strip() == "FINISHED":
+        return END
+    else:
+        return "assistant"

langgraph/source/examples/chatbots/information-gather-prompting.ipynb

@@ -0,0 +1,41 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "a9014f94",
+   "metadata": {},
+   "source": [
+    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/tutorials/chatbots/information-gather-prompting.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f47ce992",
+   "metadata": {},
+   "source": [
+    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

langgraph/source/examples/code_assistant/langgraph_code_assistant.ipynb

@@ -0,0 +1,41 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "1f2f13ca",
+   "metadata": {},
+   "source": [
+    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/tutorials/code_assistant/langgraph_code_assistant.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5e4c9bfe",
+   "metadata": {},
+   "source": [
+    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

langgraph/source/examples/customer-support/customer-support.ipynb

@@ -0,0 +1,41 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "a8232bc9",
+   "metadata": {},
+   "source": [
+    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/tutorials/customer-support/customer-support.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "63da8671",
+   "metadata": {},
+   "source": [
+    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

langgraph/source/examples/extraction/retries.ipynb

@@ -0,0 +1,41 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "8dbdba5b",
+   "metadata": {},
+   "source": [
+    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/tutorials/extraction/retries.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1d444b7f",
+   "metadata": {},
+   "source": [
+    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

langgraph/source/examples/human_in_the_loop/wait-user-input.ipynb

@@ -0,0 +1,41 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "3ecab357",
+   "metadata": {},
+   "source": [
+    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/how-tos/human_in_the_loop/wait-user-input.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3f2866bd",
+   "metadata": {},
+   "source": [
+    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

langgraph/source/examples/lats/lats.ipynb

@@ -0,0 +1,41 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "09038b53",
+   "metadata": {},
+   "source": [
+    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/tutorials/lats/lats.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b1669748",
+   "metadata": {},
+   "source": [
+    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

langgraph/source/examples/llm-compiler/LLMCompiler.ipynb

@@ -0,0 +1,41 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "85205e97",
+   "metadata": {},
+   "source": [
+    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/tutorials/llm-compiler/LLMCompiler.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2fdab366",
+   "metadata": {},
+   "source": [
+    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

langgraph/source/examples/multi_agent/hierarchical_agent_teams.ipynb

@@ -0,0 +1,41 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "5cc8a2ad",
+   "metadata": {},
+   "source": [
+    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/tutorials/multi_agent/hierarchical_agent_teams.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b9f3508a",
+   "metadata": {},
+   "source": [
+    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

langgraph/source/examples/multi_agent/multi-agent-collaboration.ipynb

@@ -0,0 +1,41 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "d2b507b9",
+   "metadata": {},
+   "source": [
+    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/tutorials/multi_agent/multi-agent-collaboration.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "41a8f10a",
+   "metadata": {},
+   "source": [
+    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

langgraph/source/examples/plan-and-execute/plan-and-execute.ipynb

@@ -0,0 +1,41 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "9138f92e",
+   "metadata": {},
+   "source": [
+    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/tutorials/plan-and-execute/plan-and-execute.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "093678ba",
+   "metadata": {},
+   "source": [
+    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

langgraph/source/examples/react-agent-from-scratch.ipynb

@@ -0,0 +1,40 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "294995c4",
+   "metadata": {},
+   "source": [
+    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/how-tos/react-agent-from-scratch.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

langgraph/source/examples/react-agent-structured-output.ipynb

@@ -0,0 +1,40 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "40f0d107",
+   "metadata": {},
+   "source": [
+    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/how-tos/react-agent-structured-output.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

langgraph/source/examples/reflection/reflection.ipynb

@@ -0,0 +1,41 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "658773a2",
+   "metadata": {},
+   "source": [
+    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/tutorials/reflection/reflection.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1cb60657",
+   "metadata": {},
+   "source": [
+    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

langgraph/source/examples/reflexion/reflexion.ipynb

@@ -0,0 +1,41 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "caf07859",
+   "metadata": {},
+   "source": [
+    "[This file has been moved](https://github.com/langchain-ai/langgraph/blob/23961cff61a42b52525f3b20b4094d8d2fba1744/docs/docs/tutorials/reflexion/reflexion.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cd1df0e0",
+   "metadata": {},
+   "source": [
+    "This directory is retained purely for archival purposes and is no longer updated. The examples previously found here have been moved to the newly [consolidated LangChain documentation](https://docs.langchain.com/oss/python/langgraph/overview)."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}