@assistant-ui/mcp-docs-server 0.1.7 → 0.1.9

package/.docs/raw/docs/migrations/v0-12.mdx

@@ -0,0 +1,125 @@
+---
+title: Migration to v0.12
+---
+
+## Major Architecture Change: Unified State API
+
+Version 0.12 introduces a complete rewrite of the state management system with a more consistent API.
+
+## Breaking Changes
+
+### 1. Context Hooks Replaced with Unified State API
+
+All individual context hooks have been replaced with a single `useAssistantState` hook and `useAssistantApi` for actions.
+
+#### What changed
+
+The following hooks have been removed:
+
+**Removed Hooks:**
+
+- `useMessageUtils` → Use `useAssistantState(({ message }) => message.isHovering)` / `useAssistantState(({ message }) => message.isCopied)`
+- `useMessageUtilsStore` → Use `useAssistantApi()` with `api.message().setIsHovering()` / `api.message().setIsCopied()`
+- `useToolUIs` → Use `useAssistantState(({ toolUIs }) => toolUIs)` and `useAssistantApi()` with `api.toolUIs()`
+- `useToolUIsStore` → Use `useAssistantApi()` with `api.toolUIs()`
+
+**Deprecated Hooks:**
+
+- `useAssistantRuntime` → Use `useAssistantApi()`
+- `useThread` → Use `useAssistantState(({ thread }) => thread)`
+- `useThreadRuntime` → Use `useAssistantApi()` with `api.thread()`
+- `useMessage` → Use `useAssistantState(({ message }) => message)`
+- `useMessageRuntime` → Use `useAssistantApi()` with `api.message()`
+- `useComposer` → Use `useAssistantState(({ composer }) => composer)`
+- `useComposerRuntime` → Use `useAssistantApi()` with `api.composer()`
+- `useEditComposer` → Use `useAssistantState(({ message }) => message.composer)`
+- `useThreadListItem` → Use `useAssistantState(({ threadListItem }) => threadListItem)`
+- `useThreadListItemRuntime` → Use `useAssistantApi()` with `api.threadListItem()`
+- `useMessagePart` → Use `useAssistantState(({ part }) => part)`
+- `useMessagePartRuntime` → Use `useAssistantApi()` with `api.part()`
+- `useAttachment` → Use `useAssistantState(({ attachment }) => attachment)`
+- `useAttachmentRuntime` → Use `useAssistantApi()` with `api.attachment()`
+- `useThreadModelContext` / `useThreadModelConfig` → Use `useAssistantState(({ thread }) => thread.modelContext)`
+- `useThreadComposer` → Use `useAssistantState(({ thread }) => thread.composer)`
+- `useThreadList` → Use `useAssistantState(({ threads }) => threads)`
+
+#### Migration Examples
+
+**Before:**
+
+```tsx
+import {
+  useThread,
+  useThreadRuntime,
+  useComposer,
+  useComposerRuntime,
+  useMessage,
+  useMessageRuntime,
+} from "@assistant-ui/react";
+
+function MyComponent() {
+  // Reading state
+  const messages = useThread((t) => t.messages);
+  const isRunning = useThread((t) => t.isRunning);
+  const composerText = useComposer((c) => c.text);
+  const messageRole = useMessage((m) => m.role);
+
+  // Using runtime for actions
+  const threadRuntime = useThreadRuntime();
+  const composerRuntime = useComposerRuntime();
+  const messageRuntime = useMessageRuntime();
+
+  const handleSend = () => {
+    composerRuntime.send();
+  };
+
+  const handleReload = () => {
+    messageRuntime.reload();
+  };
+
+  const handleCancel = () => {
+    threadRuntime.cancelRun();
+  };
+
+  return null;
+}
+```
+
+**After:**
+
+```tsx
+import { useAssistantState, useAssistantApi } from "@assistant-ui/react";
+
+function MyComponent() {
+  // Reading state - all through single hook
+  const messages = useAssistantState(({ thread }) => thread.messages);
+  const isRunning = useAssistantState(({ thread }) => thread.isRunning);
+  const composerText = useAssistantState(({ composer }) => composer.text);
+  const messageRole = useAssistantState(({ message }) => message.role);
+
+  // Using API for actions
+  const api = useAssistantApi();
+
+  const handleSend = () => {
+    api.composer().send();
+  };
+
+  const handleReload = () => {
+    api.message().reload();
+  };
+
+  const handleCancel = () => {
+    api.thread().cancelRun();
+  };
+
+  return null;
+}
+```
+
+## Getting Help
+
+If you encounter issues during migration:
+
+1. Check the updated API documentation for detailed examples
+2. Review the example applications in the repository
+3. Report issues at https://github.com/assistant-ui/assistant-ui/issues

package/.docs/raw/docs/runtimes/ai-sdk/use-chat.mdx

@@ -130,7 +130,7 @@ const runtime = useChatRuntime({
 <Callout type="info">
   By default, `useChatRuntime` uses `AssistantChatTransport` which automatically
   forwards system messages and frontend tools to your backend API. This enables
-  your backend to receive the full context from the Assistant UI.
+  your backend to receive the full context from the assistant-ui.
 </Callout>
 
 ### Custom Transport Configuration
@@ -165,7 +165,7 @@ const runtime = useChatRuntime({
 
 #### Transport Options
 
-- **`AssistantChatTransport`** (default): Automatically forwards system messages and frontend tools from the Assistant UI context to your backend
+- **`AssistantChatTransport`** (default): Automatically forwards system messages and frontend tools from the assistant-ui context to your backend
 - **`DefaultChatTransport`**: Standard AI SDK transport without automatic forwarding
 
 ### Using Frontend Tools with `frontendTools`

package/.docs/raw/docs/runtimes/custom/local.mdx

@@ -414,6 +414,8 @@ import {
   type RemoteThreadListAdapter,
   type ThreadHistoryAdapter,
 } from "@assistant-ui/react";
+import { createAssistantStream } from "assistant-stream";
+import { useMemo } from "react";
 
 // Implement your custom adapter with proper message persistence
 const myDatabaseAdapter: RemoteThreadListAdapter = {
@@ -453,9 +455,16 @@ const myDatabaseAdapter: RemoteThreadListAdapter = {
 
   async generateTitle(remoteId, messages) {
     // Generate title from messages using your AI
-    const title = await generateTitle(messages);
-    await db.threads.update(remoteId, { title });
-    return new ReadableStream(); // Return empty stream
+    const newTitle = await generateTitle(messages);
+
+    // Persist the title in your DB
+    await db.threads.update(remoteId, { title: newTitle });
+
+    // IMPORTANT: Return an AssistantStream so the UI updates
+    return createAssistantStream((controller) => {
+      controller.appendText(newTitle);
+      controller.close();
+    });
   },
 };
 
@@ -528,6 +537,10 @@ export function MyRuntimeProvider({ children }) {
 }
 ```
 
+<Callout type="info" title="Returning a title from generateTitle">
+  The `generateTitle` method must return an <code>AssistantStream</code> containing the title text. The easiest, type-safe way is to use <code>createAssistantStream</code> and call <code>controller.appendText(newTitle)</code> followed by <code>controller.close()</code>. Returning a raw <code>ReadableStream</code> won't update the thread list UI.
+</Callout>
+
 #### Understanding the Architecture
 
 <Callout type="info">
@@ -719,7 +732,7 @@ Provide follow-up suggestions:
 
 ```tsx
 const suggestionAdapter: SuggestionAdapter = {
-  async *get({ messages }) {
+  async *generate({ messages }) {
     // Analyze conversation context
     const lastMessage = messages[messages.length - 1];
 

package/.docs/raw/docs/runtimes/data-stream.mdx

@@ -0,0 +1,287 @@
+---
+title: Data Stream Protocol
+---
+
+import { Step, Steps } from "fumadocs-ui/components/steps";
+import { Callout } from "fumadocs-ui/components/callout";
+
+The `@assistant-ui/react-data-stream` package provides integration with data stream protocol endpoints, enabling streaming AI responses with tool support and state management.
+
+## Overview
+
+The data stream protocol is a standardized format for streaming AI responses that supports:
+
+- **Streaming text responses** with real-time updates
+- **Tool calling** with structured parameters and results
+- **State management** for conversation context
+- **Error handling** and cancellation support
+- **Attachment support** for multimodal interactions
+
+## Installation
+
+```bash npm2yarn
+npm install @assistant-ui/react-data-stream
+```
+
+## Basic Usage
+
+<Steps>
+
+<Step>
+
+### Set up the Runtime
+
+Use `useDataStreamRuntime` to connect to your data stream endpoint:
+
+```tsx title="app/page.tsx"
+"use client";
+import { useDataStreamRuntime } from "@assistant-ui/react-data-stream";
+import { AssistantRuntimeProvider } from "@assistant-ui/react";
+import { Thread } from "@/components/assistant-ui/thread";
+
+export default function ChatPage() {
+  const runtime = useDataStreamRuntime({
+    api: "/api/chat",
+  });
+
+  return (
+    <AssistantRuntimeProvider runtime={runtime}>
+      <Thread />
+    </AssistantRuntimeProvider>
+  );
+}
+```
+
+</Step>
+
+<Step>
+
+### Create Backend Endpoint
+
+Your backend endpoint should accept POST requests and return data stream responses:
+
+```typescript title="app/api/chat/route.ts"
+import { DataStreamResponse } from "assistant-stream";
+
+export async function POST(request: Request) {
+  const { messages, tools, system } = await request.json();
+
+  // Process the request with your AI provider
+  const stream = await processWithAI({
+    messages,
+    tools,
+    system,
+  });
+
+  return new DataStreamResponse(stream);
+}
+```
+
+</Step>
+
+</Steps>
+
+## Advanced Configuration
+
+### Custom Headers and Authentication
+
+```tsx
+const runtime = useDataStreamRuntime({
+  api: "/api/chat",
+  headers: {
+    "Authorization": "Bearer " + token,
+    "X-Custom-Header": "value",
+  },
+  credentials: "include",
+});
+```
+
+### Dynamic Headers
+
+```tsx
+const runtime = useDataStreamRuntime({
+  api: "/api/chat",
+  headers: async () => {
+    const token = await getAuthToken();
+    return {
+      "Authorization": "Bearer " + token,
+    };
+  },
+});
+```
+
+### Event Callbacks
+
+```tsx
+const runtime = useDataStreamRuntime({
+  api: "/api/chat",
+  onResponse: (response) => {
+    console.log("Response received:", response.status);
+  },
+  onFinish: (message) => {
+    console.log("Message completed:", message);
+  },
+  onError: (error) => {
+    console.error("Error occurred:", error);
+  },
+  onCancel: () => {
+    console.log("Request cancelled");
+  },
+});
+```
+
+## Tool Integration
+
+### Frontend Tools
+
+Use the `frontendTools` helper to serialize client-side tools:
+
+```tsx
+import { frontendTools } from "@assistant-ui/react-data-stream";
+import { makeAssistantTool } from "@assistant-ui/react";
+
+const weatherTool = makeAssistantTool({
+  toolName: "get_weather",
+  description: "Get current weather",
+  parameters: z.object({
+    location: z.string(),
+  }),
+  execute: async ({ location }) => {
+    const weather = await fetchWeather(location);
+    return `Weather in ${location}: ${weather}`;
+  },
+});
+
+const runtime = useDataStreamRuntime({
+  api: "/api/chat",
+  body: {
+    tools: frontendTools({
+      get_weather: weatherTool,
+    }),
+  },
+});
+```
+
+### Backend Tool Processing
+
+Your backend should handle tool calls and return results:
+
+```typescript title="Backend tool handling"
+// Tools are automatically forwarded to your endpoint
+const { tools } = await request.json();
+
+// Process tools with your AI provider
+const response = await ai.generateText({
+  messages,
+  tools,
+  // Tool results are streamed back automatically
+});
+```
+
+## Assistant Cloud Integration
+
+For Assistant Cloud deployments, use `useCloudRuntime`:
+
+```tsx
+import { useCloudRuntime } from "@assistant-ui/react-data-stream";
+
+const runtime = useCloudRuntime({
+  cloud: assistantCloud,
+  assistantId: "my-assistant-id",
+});
+```
+
+<Callout type="info">
+The `useCloudRuntime` hook is currently under active development and not yet ready for production use.
+</Callout>
+
+## Message Conversion
+
+The package includes utilities for converting between message formats:
+
+```tsx
+import { toLanguageModelMessages } from "@assistant-ui/react-data-stream";
+
+// Convert assistant-ui messages to language model format
+const languageModelMessages = toLanguageModelMessages(messages, {
+  unstable_includeId: true, // Include message IDs
+});
+```
+
+## Error Handling
+
+The runtime automatically handles common error scenarios:
+
+- **Network errors**: Automatically retried with exponential backoff
+- **Stream interruptions**: Gracefully handled with partial content preservation
+- **Tool execution errors**: Displayed in the UI with error states
+- **Cancellation**: Clean abort signal handling
+
+## Best Practices
+
+### Performance Optimization
+
+```tsx
+// Use React.memo for expensive components
+const OptimizedThread = React.memo(Thread);
+
+// Memoize runtime configuration
+const runtimeConfig = useMemo(() => ({
+  api: "/api/chat",
+  headers: { "Authorization": `Bearer ${token}` },
+}), [token]);
+
+const runtime = useDataStreamRuntime(runtimeConfig);
+```
+
+### Error Boundaries
+
+```tsx
+import { ErrorBoundary } from "react-error-boundary";
+
+function ChatErrorFallback({ error, resetErrorBoundary }) {
+  return (
+    <div role="alert">
+      <h2>Something went wrong:</h2>
+      <pre>{error.message}</pre>
+      <button onClick={resetErrorBoundary}>Try again</button>
+    </div>
+  );
+}
+
+export default function App() {
+  return (
+    <ErrorBoundary FallbackComponent={ChatErrorFallback}>
+      <AssistantRuntimeProvider runtime={runtime}>
+        <Thread />
+      </AssistantRuntimeProvider>
+    </ErrorBoundary>
+  );
+}
+```
+
+### State Persistence
+
+```tsx
+const runtime = useDataStreamRuntime({
+  api: "/api/chat",
+  body: {
+    // Include conversation state
+    state: conversationState,
+  },
+  onFinish: (message) => {
+    // Save state after each message
+    saveConversationState(message.metadata.unstable_state);
+  },
+});
+```
+
+## Examples
+
+- **[Basic Data Stream Example](https://github.com/assistant-ui/assistant-ui/tree/main/examples/with-data-stream)** - Simple streaming chat
+- **[Tool Integration Example](https://github.com/assistant-ui/assistant-ui/tree/main/examples/with-data-stream-tools)** - Frontend and backend tools
+- **[Authentication Example](https://github.com/assistant-ui/assistant-ui/tree/main/examples/with-data-stream-auth)** - Secure endpoints
+
+## API Reference
+
+For detailed API documentation, see the [`@assistant-ui/react-data-stream` API Reference](/docs/api-reference/integrations/react-data-stream).

package/.docs/raw/docs/runtimes/mastra/full-stack-integration.mdx

@@ -10,9 +10,9 @@ Integrate Mastra directly into your Next.js application's API routes. This appro
 <Steps>
 <Step>
 
-### Initialize Assistant UI
+### Initialize assistant-ui
 
-Start by setting up Assistant UI in your project. Run one of the following commands:
+Start by setting up assistant-ui in your project. Run one of the following commands:
 
 ```sh title="New Project"
 npx assistant-ui@latest create
@@ -190,10 +190,11 @@ export async function POST(req: Request) {
 ```
 
 Key changes:
+
 - We import the `mastra` instance created in `mastra/index.ts`. Make sure the import path (`@/mastra`) is correct for your project setup (you might need `~/mastra`, `../../../mastra`, etc., depending on your path aliases and project structure).
 - We retrieve the `chefAgent` using `mastra.getAgent("chefAgent")`.
 - Instead of calling the AI SDK's `streamText` directly, we call `agent.stream(messages)` to process the chat messages using the agent's configuration and model.
-- The result is still returned in a format compatible with Assistant UI using `toDataStreamResponse()`.
+- The result is still returned in a format compatible with assistant-ui using `toDataStreamResponse()`.
 
 Your API route is now powered by Mastra!
 
@@ -208,11 +209,11 @@ You're all set! Start your Next.js development server:
 npm run dev
 ```
 
-Open your browser to `http://localhost:3000` (or the port specified in your terminal). You should now be able to interact with your `chefAgent` through the Assistant UI chat interface. Ask it for cooking advice based on ingredients you have!
+Open your browser to `http://localhost:3000` (or the port specified in your terminal). You should now be able to interact with your `chefAgent` through the assistant-ui chat interface. Ask it for cooking advice based on ingredients you have!
 
 </Step>
 </Steps>
 
-Congratulations! You have successfully integrated Mastra into your Next.js application using the full-stack approach. Your Assistant UI frontend now communicates with a Mastra agent running in your Next.js backend API route.
+Congratulations! You have successfully integrated Mastra into your Next.js application using the full-stack approach. Your assistant-ui frontend now communicates with a Mastra agent running in your Next.js backend API route.
 
 To explore more advanced Mastra features like memory, tools, workflows, and more, please refer to the [official Mastra documentation](https://mastra.ai/docs).

package/.docs/raw/docs/runtimes/mastra/overview.mdx

@@ -4,9 +4,9 @@ title: Overview
 
 Mastra is an open-source TypeScript agent framework designed to provide the essential primitives for building AI applications. It enables developers to create AI agents with memory and tool-calling capabilities, implement deterministic LLM workflows, and leverage RAG for knowledge integration. With features like model routing, workflow graphs, and automated evals, Mastra provides a complete toolkit for developing, testing, and deploying AI applications.
 
-## Integrating with Next.js and Assistant UI
+## Integrating with Next.js and assistant-ui
 
-There are two primary ways to integrate Mastra into your Next.js project when using Assistant UI:
+There are two primary ways to integrate Mastra into your Next.js project when using assistant-ui:
 
 1.  **Full-Stack Integration**: Integrate Mastra directly into your Next.js application's API routes. This approach keeps your backend and frontend code within the same project.
     [Learn how to set up Full-Stack Integration](./full-stack-integration)
@@ -14,4 +14,4 @@ There are two primary ways to integrate Mastra into your Next.js project when us
 2.  **Separate Server Integration**: Run Mastra as a standalone server and connect your Next.js frontend to its API endpoints. This approach separates concerns and allows for independent scaling.
     [Learn how to set up Separate Server Integration](./separate-server-integration)
 
-Choose the guide that best fits your project architecture. Both methods allow seamless integration with the Assistant UI components.
+Choose the guide that best fits your project architecture. Both methods allow seamless integration with the assistant-ui components.

package/.docs/raw/docs/runtimes/mastra/separate-server-integration.mdx

@@ -5,7 +5,7 @@ title: Separate Server Integration
 import { Step, Steps } from "fumadocs-ui/components/steps";
 import { Callout } from "fumadocs-ui/components/callout";
 
-Run Mastra as a standalone server and connect your Next.js frontend (using Assistant UI) to its API endpoints. This approach separates your AI backend from your frontend application, allowing for independent development and scaling.
+Run Mastra as a standalone server and connect your Next.js frontend (using assistant-ui) to its API endpoints. This approach separates your AI backend from your frontend application, allowing for independent development and scaling.
 
 <Steps>
 
@@ -13,7 +13,7 @@ Run Mastra as a standalone server and connect your Next.js frontend (using Assis
 
 ### Create Mastra Server Project
 
-First, create a dedicated project for your Mastra server. Choose a directory separate from your Next.js/Assistant UI frontend project.
+First, create a dedicated project for your Mastra server. Choose a directory separate from your Next.js/assistant-ui frontend project.
 
 Navigate to your chosen parent directory in the terminal and run the Mastra create command:
 
@@ -97,15 +97,15 @@ With the agent defined and registered, start the Mastra development server:
 npm run dev
 ```
 
-By default, the Mastra server will run on `http://localhost:4111`. Your `chefAgent` should now be accessible via a POST request endpoint, typically `http://localhost:4111/api/agents/chefAgent/stream`. Keep this server running for the next steps where we'll set up the Assistant UI frontend to connect to it.
+By default, the Mastra server will run on `http://localhost:4111`. Your `chefAgent` should now be accessible via a POST request endpoint, typically `http://localhost:4111/api/agents/chefAgent/stream`. Keep this server running for the next steps where we'll set up the assistant-ui frontend to connect to it.
 
 </Step>
 
 <Step>
 
-### Initialize Assistant UI Frontend
+### Initialize assistant-ui Frontend
 
-Now, set up your frontend application using Assistant UI. Navigate to a **different directory** from your Mastra server project. You can either create a new Next.js project or use an existing one.
+Now, set up your frontend application using assistant-ui. Navigate to a **different directory** from your Mastra server project. You can either create a new Next.js project or use an existing one.
 
 Inside your frontend project directory, run one of the following commands:
 
@@ -117,10 +117,10 @@ npx assistant-ui@latest create
 npx assistant-ui@latest init
 ```
 
-This command installs the necessary Assistant UI dependencies and sets up basic configuration files, including a default chat page and an API route (`app/api/chat/route.ts`).
+This command installs the necessary assistant-ui dependencies and sets up basic configuration files, including a default chat page and an API route (`app/api/chat/route.ts`).
 
 <Callout title="Need Help?">
-  For detailed setup instructions for Assistant UI, including manual setup
+  For detailed setup instructions for assistant-ui, including manual setup
   steps, please refer to the main [Getting Started
   guide](/docs/getting-started).
 </Callout>
@@ -133,9 +133,9 @@ In the next step, we will configure this frontend to communicate with the separa
 
 ### Configure Frontend API Endpoint
 
-The default Assistant UI setup configures the chat runtime to use a local API route (`/api/chat`) within the Next.js project. Since our Mastra agent is running on a separate server, we need to update the frontend to point to that server's endpoint.
+The default assistant-ui setup configures the chat runtime to use a local API route (`/api/chat`) within the Next.js project. Since our Mastra agent is running on a separate server, we need to update the frontend to point to that server's endpoint.
 
-Open the main page file in your Assistant UI frontend project (usually `app/page.tsx` or `src/app/page.tsx`). Find the `useChatRuntime` hook and change the `api` property to the full URL of your Mastra agent's stream endpoint:
+Open the main page file in your assistant-ui frontend project (usually `app/page.tsx` or `src/app/page.tsx`). Find the `useChatRuntime` hook and change the `api` property to the full URL of your Mastra agent's stream endpoint:
 
 ```tsx {10} title="app/page.tsx"
 "use client";
@@ -163,7 +163,7 @@ export default function Home() {
 
 Replace `"http://localhost:4111/api/agents/chefAgent/stream"` with the actual URL if your Mastra server runs on a different port or host, or if your agent has a different name.
 
-Now, the Assistant UI frontend will send chat requests directly to your running Mastra server.
+Now, the assistant-ui frontend will send chat requests directly to your running Mastra server.
 
 <Callout title="Delete Default API Route">
   Since the frontend no longer uses the local `/api/chat` route created by the
@@ -179,18 +179,18 @@ Now, the Assistant UI frontend will send chat requests directly to your running
 
 You're ready to connect the pieces! Make sure your separate Mastra server is still running (from Step 4).
 
-In your Assistant UI frontend project directory, start the Next.js development server:
+In your assistant-ui frontend project directory, start the Next.js development server:
 
 ```bash npm2yarn
 npm run dev
 ```
 
-Open your browser to `http://localhost:3000` (or the port specified in your terminal for the frontend app). You should now be able to interact with your `chefAgent` through the Assistant UI chat interface. The frontend will make requests to your Mastra server running on `http://localhost:4111`.
+Open your browser to `http://localhost:3000` (or the port specified in your terminal for the frontend app). You should now be able to interact with your `chefAgent` through the assistant-ui chat interface. The frontend will make requests to your Mastra server running on `http://localhost:4111`.
 
 </Step>
 
 </Steps>
 
-Congratulations! You have successfully integrated Mastra with Assistant UI using a separate server approach. Your Assistant UI frontend now communicates with a standalone Mastra agent server.
+Congratulations! You have successfully integrated Mastra with assistant-ui using a separate server approach. Your assistant-ui frontend now communicates with a standalone Mastra agent server.
 
 This setup provides a clear separation between your frontend and AI backend. To explore more advanced Mastra features like memory, tools, workflows, and deployment options, please refer to the [official Mastra documentation](https://mastra.ai/docs).

package/.docs/raw/docs/runtimes/pick-a-runtime.mdx

@@ -48,6 +48,11 @@ For popular frameworks, we provide ready-to-use integrations built on top of our
     description="For useChat and useAssistant hooks - streaming with all major providers"
     href="/docs/runtimes/ai-sdk/use-chat"
   />
+  <Card
+    title="Data Stream Protocol"
+    description="For custom backends using the data stream protocol standard"
+    href="/docs/runtimes/data-stream"
+  />
   <Card
     title="LangGraph"
     description="For complex agent workflows with LangChain's graph framework"