Initial MKDocs (#285)

docs/docs/concepts.md

@@ -0,0 +1,4 @@
+# Concepts
+
+
+## State

docs/docs/how-tos/index.md

@@ -0,0 +1,25 @@
+# How-To Guides
+
+Welcome to the LangGraph How-To Guides! These guides provide practical, step-by-step instructions for accomplishing key tasks in LangGraph.
+
+## Basics
+
+- [State Management](state-model.ipynb): How to define and manage complex state in your graphs
+- [Tool Integration](sql_example.ipynb): How to integrate external tools and data sources
+- [Human-in-the-Loop](human-in-the-loop.ipynb): How to incorporate human feedback and intervention
+
+## Performance
+
+- [Async Execution](async.ipynb): How to run nodes asynchronously for improved performance
+- [Streaming Responses](streaming-tokens.ipynb): How to stream agent responses in real-time
+
+## Graph Structure
+
+- [Subgraphs](subgraph.ipynb): How to modularize your graphs with subgraphs
+- [Branching](branching.ipynb): How to create branching logic in your graphs
+
+## Development
+
+- [Persistence](persistence.ipynb): How to save and load graph state for long-running applications
+- [Visualization](visualization.ipynb): How to visualize your graphs
+- [Time Travel](time-travel.ipynb): How to navigate and manipulate graph execution history

docs/docs/index.md

@@ -0,0 +1,122 @@
+# 🦜🕸️LangGraph
+
+[![Downloads](https://static.pepy.tech/badge/langgraph/month)](https://pepy.tech/project/langgraph)
+
+⚡ Build language agents as graphs ⚡
+
+
+## Overview
+
+Suppose you're building a customer support assistant. You want your assistant to:
+
+1. Try to answer user questions using a knowledge base
+2. Escalate to a human if it's not confident in its answer
+3. Relay the human's resolution back to the user
+4. Remember the full conversation context across multiple user messages
+
+With raw LLMs, the code to control the agentic loop, conversation state, route between the chatbot and human, and checkpoint the full application state can get complex.
+
+LangGraph makes it simple. First install:
+
+```shell
+pip install -U langgraph
+```
+
+Then define your assistant:
+
+```python
+from langgraph.graph import StateGraph
+from langgraph.checkpoint.sqlite import SqliteSaver
+
+from langchain_anthropic
+
+
+# Define the chatbot state 
+class ChatbotState(TypedDict):
+    conversation_history: Annotated[ConversationHistory, operator.add]
+    pending_human_request: Optional[HumanRequest]
+
+# Create nodes for the chatbot and human
+def chatbot(state: ChatbotState):
+    # TODO
+
+def human(state: ChatbotState):
+    # TODO
+
+# Create the graph
+graph = StateGraph(ChatbotState)
+graph.add_node("chatbot", chatbot)
+graph.add_node("human", human)
+
+# Define routing logic between chatbot and human
+def should_escalate(state):
+    if state['pending_human_request']:
+        return "human"
+    else:
+        return "chatbot"
+
+graph.add_conditional_edges("chatbot", should_escalate, {
+    "human": "human", 
+    "chatbot": "chatbot"
+})
+
+graph.add_edge("human", "chatbot")
+
+memory = SqliteSaver.from_conn_string(":memory:")
+app = graph.compile(checkpointer=memory)
+# Run the graph
+result = app.invoke(new_user_message)
+```
+
+The graph handles all the hard parts:
+
+- `conversation_history` in the state contains the assistant's "memory"
+- Conditional edges enable dynamic routing between the chatbot and human based on the chatbot's confidence
+- Persistence makes it easy to route to a human so they can respond and resume at any time
+
+With LangGraph, you can build complex, stateful agents without getting bogged down in manual state and interrupt management. Just define your nodes, edges, and state schema - and let the graph take care of the rest.
+
+## Concepts
+
+- [Graphs](concepts.md#graphs)
+- [State](concepts.md#state): The data structure passed between nodes, allowing you to persist context 
+- [Nodes](concepts.#nodes): The building blocks of your graph - LLMs, tools, or custom logic 
+- [Edges](concepts.md#edges): The connections that define the flow of data between your nodes
+- [Conditional Edges](concepts.md#conditional_edges): Special edges that let you dynamically route between nodes based on state
+- [Persistence](concepts.md#persistence): Save and resume your graph's state for long-running applications
+
+## How-To Guides
+
+Check out the [How-To Guides](how-tos/index.md) for instructions on handling common tasks with LangGraph.
+
+- Manage State
+- Tool Integration  
+- Human-in-the-Loop
+- Async Execution
+- Streaming Responses
+- Subgraphs & Branching
+- Persistence, Visualization, Time Travel 
+- Benchmarking
+
+## Tutorials
+
+Consult the [Tutorials](tutorials/index.md) to learn more about implementing advanced 
+
+- **Agent Executors**: Chat and Langchain agents
+- **Planning Agents**: Plan-and-Execute, ReWOO, LLMCompiler  
+- **Reflection & Critique**: Improving quality via reflection
+- **Multi-Agent Systems**: Collaboration, supervision, teams
+- **Research & QA**: Web research, retrieval-augmented QA  
+- **Applications**: Chatbots, code assist, web tasks
+- **Evaluation & Analysis**: Simulation, self-discovery, swarms
+
+## Why LangGraph?
+
+LangGraph extends the core strengths of LangChain Runnables (shared interface for streaming, async, and batch calls) to make it easy to:
+
+- Seamless state management across multiple turns of conversation or tool usage
+- The ability to flexibly route between nodes based on dynamic criteria 
+- Smooth switching between LLMs and human intervention  
+- Persistence for long-running, multi-session applications
+
+If you're building a straightforward DAG,, LangChain expression language is a great fit. But for more complex, stateful applications with nonlinear flows, LangGraph is the perfect tool for the job.

docs/docs/reference/checkpoints.md

@@ -0,0 +1,11 @@
+# Checkpoints
+
+
+::: langgraph.checkpoint
+    handler: python
+    options:
+      selection:
+        docstring_style: google
+      rendering:
+        heading_level: 3
+      show_root_toc_entry: false

docs/docs/reference/graphs.md

@@ -0,0 +1,11 @@
+# StateGraph
+
+
+::: langgraph.graph
+    handler: python
+    options:
+      selection:
+        docstring_style: google
+      rendering:
+        heading_level: 3
+      show_root_toc_entry: false

docs/docs/reference/prebuilt.md

@@ -0,0 +1,11 @@
+# Prebuilt 
+
+
+::: langgraph.prebuilt
+    handler: python
+    options:
+      selection:
+        docstring_style: google
+      rendering:
+        heading_level: 3
+      show_root_toc_entry: false

docs/docs/tutorials/index.md

@@ -0,0 +1,69 @@
+# Tutorials
+
+Welcome to the LangGraph Tutorials! These notebooks provide end-to-end walkthroughs for building various types of language agents and applications using LangGraph.
+
+## Agent Executors
+
+- **Chat Agent (Function Calling)**
+    - [Base](chat_agent_executor_with_function_calling/base.ipynb): Implementing a chat agent executor with function calling
+    - [High-Level](chat_agent_executor_with_function_calling/high-level.ipynb): Using the high-level chat agent executor API
+    - [High-Level Tools](chat_agent_executor_with_function_calling/high-level-tools.ipynb): Integrating tools into the high-level chat agent executor
+    - **Modifications**
+        - [Human-in-the-Loop](chat_agent_executor_with_function_calling/human-in-the-loop.ipynb)
+        - [Force Tool First](chat_agent_executor_with_function_calling/force-calling-a-tool-first.ipynb)
+        - [Respond in Format](chat_agent_executor_with_function_calling/respond-in-format.ipynb)
+        - [Dynamic Direct Return](chat_agent_executor_with_function_calling/dynamically-returning-directly.ipynb)
+        - [Manage Agent Steps](chat_agent_executor_with_function_calling/managing-agent-steps.ipynb)
+
+- **LangChain Agent**
+    - [Base](agent_executor/base.ipynb): Implementing an agent executor with Langchain agents  
+    - [High-Level](agent_executor/high-level.ipynb): Using the high-level Langchain agent executor API
+    - **Modifications** 
+        - [Human-in-the-Loop](agent_executor/human-in-the-loop.ipynb)
+        - [Force Tool First](agent_executor/force-calling-a-tool-first.ipynb)
+        - [Manage Agent Steps](agent_executor/managing-agent-steps.ipynb)
+
+## Planning Agents
+
+- [Plan-and-Execute](plan-and-execute/plan-and-execute.ipynb): Implementing a basic planning and execution agent  
+- [Reasoning without Observation](rewoo/rewoo.ipynb): Reducing re-planning by saving observations as variables 
+- [LLMCompiler](llm-compiler/LLMCompiler.ipynb): Streaming and eagerly executing a DAG of tasks from a planner
+
+## Reflection & Critique 
+
+- [Basic Reflection](reflection/reflection.ipynb): Prompting the agent to reflect on and revise its outputs
+- [Reflexion](reflexion/reflexion.ipynb): Critiquing missing and superfluous details to guide next steps
+- [Language Agent Tree Search](lats/lats.ipynb): Using reflection and rewards to drive a tree search over agents
+
+## Multi-Agent Systems
+
+- [Collaboration](multi_agent/multi-agent-collaboration.ipynb): Enabling two agents to collaborate on a task  
+- [Supervision](multi_agent/agent_supervisor.ipynb): Using an LLM to orchestrate and delegate to individual agents
+- [Hierarchical Teams](multi_agent/hierarchical_agent_teams.ipynb): Orchestrating nested teams of agents to solve problems
+
+## Research & QA
+
+- **Retrieval-Augmented Generation**
+    - [langgraph_adaptive_rag.ipynb](rag/langgraph_adaptive_rag.ipynb)
+    - [langgraph_adaptive_rag_cohere.ipynb](rag/langgraph_adaptive_rag_cohere.ipynb) 
+    - [langgraph_adaptive_rag_local.ipynb](rag/langgraph_adaptive_rag_local.ipynb)
+    - [langgraph_agentic_rag.ipynb](rag/langgraph_agentic_rag.ipynb)
+    - [langgraph_crag.ipynb](rag/langgraph_crag.ipynb)
+    - [langgraph_crag_local.ipynb](rag/langgraph_crag_local.ipynb)
+    - [langgraph_self_rag.ipynb](rag/langgraph_self_rag.ipynb)
+    - [langgraph_self_rag_local.ipynb](rag/langgraph_self_rag_local.ipynb)
+- [Web Research (STORM)](storm/storm.ipynb): Generating Wikipedia-like articles via research and multi-perspective QA
+
+## Applications
+
+- **Chatbots**
+    - [Customer Support](chatbots/customer-support.ipynb): Building a customer support chatbot
+    - [Info Gathering](chatbots/information-gather-prompting.ipynb): Building an information gathering chatbot  
+- [Code Assistant](code_assistant/langgraph_code_assistant.ipynb): Building a code analysis and generation assistant
+- [Web Navigation](web-navigation/web_voyager.ipynb): Building an agent that can navigate and interact with websites
+
+## Evaluation & Analysis
+
+- **Chatbot Evaluation via Simulation**  
+    - [Agent-based](chatbot-simulation-evaluation/agent-simulation-evaluation.ipynb): Evaluating chatbots via simulated user interactions
+    - [Dataset-based](chatbot-simulation-evaluation/langsmith-agent-simulation-evaluation.ipynb): Evaluating chatbots over a dialog dataset