@assistant-ui/mcp-docs-server 0.1.22 → 0.1.23

package/.docs/raw/docs/cloud/overview.mdx

@@ -1,56 +1,46 @@
 ---
 title: Overview
-description: Hosted service for thread management, chat history, and user authentication.
+description: Add thread persistence and chat history to your AI app in minutes.
 ---
 
-Assistant Cloud is a hosted service built for assistant-ui frontends that offers comprehensive thread management and message history. It automatically persists threads, supports human-in-the-loop workflows, and integrates with common auth providers to seamlessly allow users to resume conversations at any point.
+Assistant Cloud is a hosted service that adds thread management, message persistence, and user authorization to AI chat applications. It works with any React UI—whether you use assistant-ui components or your own.
 
+## What You Get
 
-## Features
+- **Thread Persistence** — Messages automatically save as conversations progress. Users can resume chats at any time, even across sessions.
+- **Thread List** — Built-in UI components (or hooks) for browsing, switching, and managing conversations.
+- **Auto-Generated Titles** — Conversations get meaningful titles based on the initial messages.
+- **User Authorization** — Integrates with your auth provider to scope threads per user or workspace.
 
-### Thread management
+## Supported Backends
 
-Using our `<ThreadList />` component, show the users a list of conversations. Allow the users to seamlessly switch between conversations and even let long running tasks run in the background.
+| Backend | Standalone Mode | With assistant-ui |
+|---------|----------------|-------------------|
+| AI SDK | [`useCloudChat`](/docs/cloud/ai-sdk) | [`useChatRuntime`](/docs/cloud/ai-sdk-assistant-ui) |
+| LangGraph | — | [`useLangGraphRuntime`](/docs/cloud/langgraph) |
+| Custom | — | Local Runtime |
 
-Assistant Cloud automatically persists a list of threads and corresponding metadata. It also automatically generates a title for conversations based on the initial messages.
-
-Supported backends:
-
-- AI SDK
-- LangGraph
-- Custom
-
-### Chat history
-
-For every conversation, Assistant Cloud can store the history of messages, allowing the user to resume the conversation at any point in time.
-This supports human in the loop workflows, where the execution of an agent is interrupted until user feedback is collected.
-
-Supported backends:
-
-- AI SDK
-- LangGraph
-- Custom (currently only Local Runtime)
-
-### Authorization
+## Getting Started
 
-Assistant Cloud integrates with your auth provider (Clerk, Auth0, Supabase, Firebase, ...) to identify your users and authorize them to access just the conversations they are allowed to see.
+<Callout type="info">
+  You'll need an Assistant Cloud account. [Sign up here](https://cloud.assistant-ui.com/) to create a project.
 
-Supported auth providers:
+  From your project settings, copy the **Frontend API URL** (`https://proj-[ID].assistant-api.com`)—you'll need it for the guides below.
+</Callout>
 
-- Clerk
-- Auth0
-- Supabase
-- Firebase
-- Your own
+### Choose Your Integration Path
 
-## Getting Started
+**Using AI SDK with your own UI?**  
+→ Follow the [AI SDK guide](/docs/cloud/ai-sdk) for the `useCloudChat` hook. One hook, minimal changes to your existing code.
 
-To get started, create an account at [Assistant Cloud Dashboard](https://cloud.assistant-ui.com/) and follow one of the walkthroughs for your preferred backend:
+**Want pre-built components like `<Thread />` and `<ThreadList />`?**  
+→ Follow the [AI SDK + assistant-ui guide](/docs/cloud/ai-sdk-assistant-ui) for full UI components with cloud persistence.
 
-- [AI SDK](/docs/cloud/persistence/ai-sdk)
-- [LangGraph](/docs/cloud/persistence/langgraph)
+**Using LangGraph?**  
+→ Follow the [LangGraph guide](/docs/cloud/langgraph) for cloud-backed LangGraph Cloud integration.
 
-You can also check out our example repositories to see how to integrate Assistant Cloud with your frontend:
+## Example Repositories
 
-- [With AI SDK](https://github.com/assistant-ui/assistant-ui/tree/main/examples/with-cloud)
-- [With LangGraph](https://github.com/assistant-ui/assistant-ui/tree/main/examples/with-langgraph)
+- [AI SDK (standalone)](https://github.com/assistant-ui/assistant-ui/tree/main/examples/with-cloud-standalone) — Minimal `useCloudChat` setup
+- [AI SDK + assistant-ui](https://github.com/assistant-ui/assistant-ui/tree/main/examples/with-cloud) — Full component integration
+- [LangGraph + assistant-ui](https://github.com/assistant-ui/assistant-ui/tree/main/examples/with-langgraph) — LangGraph Cloud with persistence

package/.docs/raw/docs/react-native/adapters.mdx

@@ -0,0 +1,118 @@
+---
+title: Adapters
+description: Storage and title generation adapters for React Native.
+---
+
+Adapters customize how the local runtime persists threads and generates titles. Pass them to `useLocalRuntime` via options.
+
+```tsx
+import AsyncStorage from "@react-native-async-storage/async-storage";
+import {
+  useLocalRuntime,
+  createSimpleTitleAdapter,
+} from "@assistant-ui/react-native";
+
+const runtime = useLocalRuntime(chatModel, {
+  storage: AsyncStorage,
+  titleGenerator: createSimpleTitleAdapter(),
+});
+```
+
+## Storage
+
+The `storage` option accepts any object with `getItem`, `setItem`, and `removeItem` methods (matching the `AsyncStorage` interface). When provided, threads and messages are persisted across app restarts.
+
+```tsx
+type AsyncStorageLike = {
+  getItem(key: string): Promise<string | null>;
+  setItem(key: string, value: string): Promise<void>;
+  removeItem(key: string): Promise<void>;
+};
+```
+
+### AsyncStorage
+
+The most common choice for React Native:
+
+```tsx
+import AsyncStorage from "@react-native-async-storage/async-storage";
+
+const runtime = useLocalRuntime(chatModel, {
+  storage: AsyncStorage,
+});
+```
+
+An optional `storagePrefix` parameter namespaces the keys:
+
+```tsx
+const runtime = useLocalRuntime(chatModel, {
+  storage: AsyncStorage,
+  storagePrefix: "chat:",
+  // Keys: "chat:threads", "chat:messages:<threadId>", ...
+});
+```
+
+### No storage (default)
+
+When `storage` is omitted, threads live in memory only — lost on app restart.
+
+```tsx
+const runtime = useLocalRuntime(chatModel);
+```
+
+### Advanced: createLocalStorageAdapter
+
+For more control, use `createLocalStorageAdapter` directly to create a `RemoteThreadListAdapter`:
+
+```tsx
+import AsyncStorage from "@react-native-async-storage/async-storage";
+import {
+  createLocalStorageAdapter,
+  createSimpleTitleAdapter,
+} from "@assistant-ui/react-native";
+
+const adapter = createLocalStorageAdapter({
+  storage: AsyncStorage,
+  prefix: "chat:",
+  titleGenerator: createSimpleTitleAdapter(),
+});
+```
+
+## TitleGenerationAdapter
+
+Generates a title for a thread based on its messages.
+
+```tsx
+interface TitleGenerationAdapter {
+  generateTitle(messages: ThreadMessage[]): Promise<string>;
+}
+```
+
+### Built-in implementations
+
+#### Simple title adapter
+
+Returns the first 50 characters of the first user message.
+
+```tsx
+import { createSimpleTitleAdapter } from "@assistant-ui/react-native";
+
+const titleGenerator = createSimpleTitleAdapter();
+```
+
+### Custom implementation
+
+```tsx
+import type { TitleGenerationAdapter } from "@assistant-ui/react-native";
+
+const aiTitleGenerator: TitleGenerationAdapter = {
+  async generateTitle(messages) {
+    const response = await fetch("/api/generate-title", {
+      method: "POST",
+      body: JSON.stringify({ messages }),
+    });
+    const { title } = await response.json();
+    return title;
+  },
+};
+```

package/.docs/raw/docs/react-native/custom-backend.mdx

@@ -0,0 +1,210 @@
+---
+title: Custom Backend
+description: Connect your React Native app to your own backend API.
+---
+
+By default, `useLocalRuntime` manages threads and messages on-device. You can connect to your own backend in two ways depending on your needs.
+
+## Option 1: ChatModelAdapter only
+
+The simplest approach — keep thread management local, but send messages to your backend for inference.
+
+```tsx title="adapters/my-chat-adapter.ts"
+import type { ChatModelAdapter } from "@assistant-ui/react-native";
+
+export const myChatAdapter: ChatModelAdapter = {
+  async *run({ messages, abortSignal }) {
+    const response = await fetch("https://my-api.com/chat", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ messages }),
+      signal: abortSignal,
+    });
+
+    const reader = response.body?.getReader();
+    if (!reader) throw new Error("No response body");
+
+    const decoder = new TextDecoder();
+    let fullText = "";
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      const chunk = decoder.decode(value, { stream: true });
+      fullText += chunk;
+      yield { content: [{ type: "text", text: fullText }] };
+    }
+  },
+};
+```
+
+```tsx title="hooks/use-app-runtime.ts"
+import AsyncStorage from "@react-native-async-storage/async-storage";
+import { useLocalRuntime } from "@assistant-ui/react-native";
+import { myChatAdapter } from "@/adapters/my-chat-adapter";
+
+export function useAppRuntime() {
+  return useLocalRuntime(myChatAdapter, {
+    storage: AsyncStorage, // threads + messages persisted locally
+  });
+}
+```
+
+This gives you:
+
+- Streaming chat responses from your API
+- Local thread list with persistence (AsyncStorage)
+- Message history saved across app restarts
+
+## Option 2: Full backend thread management
+
+When you want your backend to own thread state (e.g. for cross-device sync, team sharing, or server-side history), implement a `RemoteThreadListAdapter`.
+
+<Steps>
+  <Step>
+
+### Implement the adapter
+
+```tsx title="adapters/my-thread-list-adapter.ts"
+import type { RemoteThreadListAdapter } from "@assistant-ui/react-native";
+import { createAssistantStream } from "assistant-stream";
+
+const API_BASE = "https://my-api.com";
+
+export const myThreadListAdapter: RemoteThreadListAdapter = {
+  async list() {
+    const res = await fetch(`${API_BASE}/threads`);
+    const threads = await res.json();
+    return {
+      threads: threads.map((t: any) => ({
+        remoteId: t.id,
+        status: t.archived ? "archived" : "regular",
+        title: t.title,
+      })),
+    };
+  },
+
+  async initialize(localId) {
+    const res = await fetch(`${API_BASE}/threads`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ localId }),
+    });
+    const { id } = await res.json();
+    return { remoteId: id, externalId: undefined };
+  },
+
+  async rename(remoteId, title) {
+    await fetch(`${API_BASE}/threads/${remoteId}`, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ title }),
+    });
+  },
+
+  async archive(remoteId) {
+    await fetch(`${API_BASE}/threads/${remoteId}/archive`, {
+      method: "POST",
+    });
+  },
+
+  async unarchive(remoteId) {
+    await fetch(`${API_BASE}/threads/${remoteId}/unarchive`, {
+      method: "POST",
+    });
+  },
+
+  async delete(remoteId) {
+    await fetch(`${API_BASE}/threads/${remoteId}`, { method: "DELETE" });
+  },
+
+  async fetch(remoteId) {
+    const res = await fetch(`${API_BASE}/threads/${remoteId}`);
+    const t = await res.json();
+    return {
+      remoteId: t.id,
+      status: t.archived ? "archived" : "regular",
+      title: t.title,
+    };
+  },
+
+  async generateTitle(remoteId, messages) {
+    return createAssistantStream(async (controller) => {
+      const res = await fetch(`${API_BASE}/threads/${remoteId}/title`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ messages }),
+      });
+      const { title } = await res.json();
+      controller.appendText(title);
+    });
+  },
+};
+```
+
+  </Step>
+  <Step>
+
+### Compose the runtime
+
+```tsx title="hooks/use-app-runtime.ts"
+import {
+  useLocalRuntime,
+  useRemoteThreadListRuntime,
+} from "@assistant-ui/react-native";
+import { myChatAdapter } from "@/adapters/my-chat-adapter";
+import { myThreadListAdapter } from "@/adapters/my-thread-list-adapter";
+
+export function useAppRuntime() {
+  return useRemoteThreadListRuntime({
+    runtimeHook: () => useLocalRuntime(myChatAdapter),
+    adapter: myThreadListAdapter,
+  });
+}
+```
+
+  </Step>
+  <Step>
+
+### Use in your app
+
+```tsx title="app/index.tsx"
+import { AssistantProvider } from "@assistant-ui/react-native";
+import { useAppRuntime } from "@/hooks/use-app-runtime";
+
+export default function App() {
+  const runtime = useAppRuntime();
+  return (
+    <AssistantProvider runtime={runtime}>
+      {/* your chat UI */}
+    </AssistantProvider>
+  );
+}
+```
+
+  </Step>
+</Steps>
+
+## Adapter methods
+
+| Method | Description |
+|--------|-------------|
+| `list()` | Return all threads on mount |
+| `initialize(localId)` | Create a thread server-side, return `{ remoteId }` |
+| `rename(remoteId, title)` | Persist title changes |
+| `archive(remoteId)` | Mark thread as archived |
+| `unarchive(remoteId)` | Restore archived thread |
+| `delete(remoteId)` | Permanently remove thread |
+| `fetch(remoteId)` | Fetch single thread metadata |
+| `generateTitle(remoteId, messages)` | Return an `AssistantStream` with the generated title |
+
+## Which option to choose?
+
+| | Option 1: ChatModelAdapter | Option 2: RemoteThreadListAdapter |
+|---|---|---|
+| **Thread storage** | On-device (AsyncStorage) | Your backend |
+| **Message storage** | On-device (AsyncStorage) | On-device (can add history adapter for server-side) |
+| **Cross-device sync** | No | Yes |
+| **Setup complexity** | Minimal | Moderate |
+| **Best for** | Single-device apps, prototypes | Production apps with user accounts |