@assistant-ui/mcp-docs-server 0.1.6 → 0.1.8

package/.docs/raw/docs/concepts/architecture.mdx

@@ -1,19 +0,0 @@
----
-title: Architecture
----
-
-import Image from "next/image";
-import architecture from "@/assets/docs/architecture.png";
-
-### Architecture
-
-`assistant-ui` consists of two parts, **_Runtime_** and **_UI Components_**.
-
-<Image
-  src={architecture}
-  alt="Architecture diagram, UI components connected to the runtime layer and the runtime layer connected to LLM and tools"
-  height={300}
-  className="mx-auto my-2 dark:hue-rotate-180 dark:invert"
-/>
-
-The Runtime and UI Components each require independent setup and both must be set up.

package/.docs/raw/docs/concepts/runtime-layer.mdx

@@ -1,163 +0,0 @@
----
-title: Runtime Layer
----
-
-assistant-ui components are full stack components. This means that they include both the UI presentation, but also logic to communicate with an external system. This logic is handled by the runtime layer and APIs.
-
-You interact with the runtime layer in two ways:
-
-- defining a runtime for your app
-- using the runtime APIs to interact with the runtime
-
-## Defining a runtime
-
-assistant-ui ships with two low-level runtimes:
-
-- `useLocalRuntime`
-- `useExternalStoreRuntime`
-
-Both of these runtimes let you implement your own runtime. The conceptual difference between the two is that `useLocalRuntime` takes ownership of the data layer, while `useExternalStoreRuntime` does not.
-
-If you have a stateful API to integrate, use `useExternalStoreRuntime`, if you have a stateless API to integrate, use `useLocalRuntime`.
-
-### Higher level runtimes
-
-For many services and APIs, assistant-ui provides deeper integrations. These are built with the two low-level runtimes mentioned above.
-
-- `useChatRuntime`: Connect to Vercel AI SDK backends
-- `useVercelUseChatRuntime`: Integrate with Vercel AI SDK's `useChat` hook
-- `useVercelUseAssistantRuntime`: Integrate with Vercel AI SDK's `useAssistant` hook (OpenAI Assistants API)
-- `useVercelRSCRuntime`: Integrate with Vercel AI SDK React Server Components
-- `useLangGraphRuntime`: Connect to LangGraph Cloud
-- ...
-
-### Runtime Providers
-
-The following components accept a `runtime` prop:
-
-- `AssistantRuntimeProvider`
-- `Thread`
-
-These components put the Runtime in the React Context, so that all child components can access the runtime.
-
-### Runtime Adapters
-
-Most runtimes accept additional adapters to configure extra integrations:
-
-- ChatModelAdapter: Configures the backend API
-- AttachmentAdapter: Configures the file/media attachment API
-- SpeechSynthesisAdapter: Configures the speech API
-- FeedbackAdapter: Configures the feedback API
-- SuggestionAdapter: Configures dynamic suggestion generation based on conversation context
-
-## Using the runtime APIs
-
-The same API used by the assistant-ui components is also available to you. This allows you to build your own UI components and integrate them with the runtime layer.
-
-### Runtime Hierarchy
-
-The runtime API is nested as such:
-
-import { File, Folder, Files } from "fumadocs-ui/components/files";
-
-<Files>
-  <Folder name="AssistantRuntime" defaultOpen>
-    <Folder name="ThreadListRuntime" defaultOpen>
-      <Folder name="ThreadRuntime" defaultOpen>
-        <Folder name="MessageRuntime" defaultOpen>
-          <Folder
-            name="MessagePartRuntime (Text / Reasoning / Image / Audio / Tool-Call / UI)"
-            defaultOpen
-          ></Folder>
-          <Folder name="MessageAttachmentRuntime" defaultOpen></Folder>
-          <Folder name="EditComposerRuntime" defaultOpen>
-            <Folder name="EditComposerAttachmentRuntime" defaultOpen></Folder>
-          </Folder>
-        </Folder>
-        <Folder name="ThreadComposerRuntime" defaultOpen>
-          <Folder name="ThreadComposerAttachmentRuntime" defaultOpen></Folder>
-        </Folder>
-      </Folder>
-    </Folder>
-  </Folder>
-</Files>
-
-The AssistantRuntime (which encompasses everything), is sometimes simply called `Runtime`.
-
-### Runtime Context Provider Components
-
-The following components provide the runtime APIs:
-
-```tsx
-// provides AssistantRuntime, ThreadListRuntime, ThreadRuntime, ComposerRuntime (ThreadComposer)
-<AssistantRuntimeProvider runtime={runtime} />
-
-// renders every message, provides MessageRuntime, ComposerRuntime (EditComposer)
-<ThreadPrimitive.Messages components={{ Message, ... }} />
-
-// renders every message part, provides MessagePartRuntime
-<MessagePrimitive.Parts components={{ Text, Reasoning, Image, Audio, UI, tools }} />
-
-// renders every attachment, provides AttachmentRuntime (Thread or EditComposer)
-<ComposerPrimitive.Attachments components={{ Attachment, ... }} />
-
-// renders every attachment, provides AtatchmentRuntime (Message)
-<MessagePrimitive.Attachments components={{ Attachment, ... }} />
-
-// provides a custom TextMessagePartRuntime
-<TextMessagePartProvider text="Hello!" />
-```
-
-### Accessing runtime APIs
-
-You can access the runtime APIs with react hooks:
-
-```tsx
-const runtime = useAssistantRuntime();
-const threadRuntime = useThreadRuntime();
-const messageRuntime = useMessageRuntime();
-const MessagePartRuntime = useMessagePartRuntime();
-
-// thread manager has no separate hook (1:1 relationship with assistant runtime)
-const ThreadListRuntime = useAssistantRuntime().threads;
-
-// composer runtime is multi-use
-const composerRuntime = useComposerRuntime(); // refers to edit composer if available, otherwise thread composer
-
-// thread manager has no separate hook (1:1 relationship with assistant runtime)
-const threadComposer = useThreadRuntime().composer;
-
-// thread manager has no separate hook (1:1 relationship with assistant runtime)
-const editComposerRuntime = useMessageRuntime().composer;
-
-// attachment runtime is multi-use
-const attachmentRuntime = useAttachmentRuntime(); // refers to the closest attachment runtime
-const threadComposerAttachmentRuntime = useThreadComposerAttachmentRuntime();
-const editComposerAttachmentRuntime = useEditComposerAttachmentRuntime();
-const messageAttachmentRuntime = useMessageAttachmentRuntime();
-```
-
-### Accessing runtime state
-
-Most runtimes also expose a state through two methods `getState` and `subscribe`. The following helper hooks subscribe to the state, so that your component is updated when the state changes:
-
-```tsx
-useThreadList(); // get thread manager state
-useThread(); // get thread state
-useMessage(); // get message state
-useMessagePart(); // get message part state
-useComposer(); // get composer state
-useThreadComposer(); // get thread composer state
-useEditComposer(); // get edit composer state
-useAttachment(); // get attachment state
-useThreadComposerAttachment(); // get thread composer attachment state
-useEditComposerAttachment(); // get edit composer attachment state
-useMessageAttachment(); // get message attachment state
-```
-
-You might not want to subscribe to evey update. In that case, pass a callback selector to the hook:
-
-```tsx
-// only subscribe to role changes
-const role = useMessage((state) => message.role);
-```

package/.docs/raw/docs/concepts/why.mdx

@@ -1,9 +0,0 @@
----
-title: Why assistant-ui?
----
-
-assistant-ui is a collection of powerful, modular primitives to build AI chat interfaces.
-
-The modular approach means that you can incrementally adopt assistant-ui (e.g. use the backend connectors and bring your own components, or use the frontend compoents and bring your own backend).
-You can also partially opt out of assistant-ui whenever you hit any limitation in the library.
-

package/.docs/raw/docs/runtimes/ai-sdk/rsc.mdx

@@ -1,226 +0,0 @@
----
-title: Vercel AI SDK RSC Runtime
----
-
-## Overview
-
-Integration with the Vercel AI SDK React Server Components. It allows streaming React components directly from the server.  
-Integrates with OpenAI, Anthropic, Mistral, Perplexity, AWS Bedrock, Azure, Google Gemini, Hugging Face, Fireworks, Cohere, LangChain, Replicate, Ollama, and more.
-
-## Example
-
-[RSC Example App](https://assistant-ui-rsc-example.vercel.app/)
-
-## Getting Started
-
-import { Steps, Step } from "fumadocs-ui/components/steps";
-import { Callout } from "fumadocs-ui/components/callout";
-
-<Steps>
-  <Step>
-  ### Create a Next.JS project
-
-```sh
-npx create-next-app@latest my-app
-cd my-app
-```
-
-  </Step>
-  <Step>
-
-### Install Vercel AI SDK and `@assistant-ui/react-ai-sdk`
-
-```sh npm2yarn
-npm install @assistant-ui/react @assistant-ui/react-ai-sdk ai @ai-sdk/openai zod nanoid
-```
-
-  </Step>
-  <Step>
-
-### Setup `actions.tsx`
-
-`@/app/actions.tsx`
-
-```tsx
-"use server";
-
-import { createAI, getMutableAIState, streamUI } from "ai/rsc";
-import { openai } from "@ai-sdk/openai";
-import { ReactNode } from "react";
-import { z } from "zod";
-import { nanoid } from "nanoid";
-
-export interface ServerMessage {
-  role: "user" | "assistant";
-  content: string;
-}
-
-export interface ClientMessage {
-  id: string;
-  role: "user" | "assistant";
-  display: ReactNode;
-}
-
-export async function continueConversation(
-  input: string,
-): Promise<ClientMessage> {
-  "use server";
-
-  const history = getMutableAIState();
-
-  const result = await streamUI({
-    model: openai("gpt-3.5-turbo"),
-    messages: [...history.get(), { role: "user", content: input }],
-    text: ({ content, done }) => {
-      if (done) {
-        history.done((messages: ServerMessage[]) => [
-          ...messages,
-          { role: "assistant", content },
-        ]);
-      }
-
-      return <div>{content}</div>;
-    },
-    tools: {
-      deploy: {
-        description: "Deploy repository to vercel",
-        parameters: z.object({
-          repositoryName: z
-            .string()
-            .describe("The name of the repository, example: vercel/ai-chatbot"),
-        }),
-        generate: async function* ({ repositoryName }) {
-          yield <div>Cloning repository {repositoryName}...</div>; // [!code highlight:5]
-          await new Promise((resolve) => setTimeout(resolve, 3000));
-          yield <div>Building repository {repositoryName}...</div>;
-          await new Promise((resolve) => setTimeout(resolve, 2000));
-          return <div>{repositoryName} deployed!</div>;
-        },
-      },
-    },
-  });
-
-  return {
-    id: nanoid(),
-    role: "assistant",
-    display: result.value,
-  };
-}
-
-export const AI = createAI<ServerMessage[], ClientMessage[]>({
-  actions: {
-    continueConversation,
-  },
-  initialAIState: [],
-  initialUIState: [],
-});
-```
-
-  </Step>
-  <Step>
-
-### Define a `MyRuntimeProvider` component
-
-`@/app/MyRuntimeProvider.tsx`
-
-```tsx
-"use client";
-
-import {
-  type AppendMessage,
-  AssistantRuntimeProvider,
-} from "@assistant-ui/react";
-import { useVercelRSCRuntime } from "@assistant-ui/react-ai-sdk";
-import { useActions, useUIState } from "ai/rsc";
-import { nanoid } from "nanoid";
-
-import type { AI } from "./actions";
-
-export function MyRuntimeProvider({
-  children,
-}: Readonly<{
-  children: React.ReactNode;
-}>) {
-  const { continueConversation } = useActions();
-  const [messages, setMessages] = useUIState<typeof AI>();
-
-  const onNew = async (m: AppendMessage) => {
-    if (m.content[0]?.type !== "text")
-      throw new Error("Only text messages are supported");
-
-    const input = m.content[0].text;
-    setMessages((currentConversation) => [
-      ...currentConversation,
-      { id: nanoid(), role: "user", display: input },
-    ]);
-
-    const message = await continueConversation(input);
-
-    setMessages((currentConversation) => [...currentConversation, message]);
-  };
-
-  const runtime = useVercelRSCRuntime({ messages, onNew });
-
-  return (
-    <AssistantRuntimeProvider runtime={runtime}>
-      {children}
-    </AssistantRuntimeProvider>
-  );
-}
-```
-
-  </Step>
-  <Step>
-
-### Wrap your app in `AI` and `MyRuntimeProvider`
-
-`@/app/layout.tsx`
-
-```tsx {1-2,12-13,19-20}
-import { AI } from '@/app/actions';
-import { MyRuntimeProvider } from '@/app/MyRuntimeProvider';
-
-...
-
-export default function RootLayout({
-  children,
-}: Readonly<{
-  children: React.ReactNode;
-}>) {
-  return (
-    <AI>
-      <MyRuntimeProvider>
-        <html lang="en">
-          <body className={inter.className}>
-            {children}
-          </body>
-        </html>
-      </MyRuntimeProvider>
-    </AI>
-  )
-}
-```
-
-  </Step>
-</Steps>
-
-## Set up RSCDisplay
-
-Pass the `RSCDisplay` component to your `MessagePrimitive.Parts`:
-
-```tsx
-<MessagePrimitive.Parts components={{ Text: RSCDisplay }} />
-```
-
-(if you are using react-ui: `<Thread assistantMessage={{ components: { Text: RSCDisplay } }} />`)
-
-## Accessing AI SDK Messages
-
-You can use the `getExternalStoreMessages` utility to convert `ThreadMessage`s back to your message format.
-
-```tsx
-const MyAssistantMessage = () => {
-  const myMessage = useMessage((m) => getExternalStoreMessages(m)[0]);
-  // ...
-};
-```

package/.docs/raw/docs/runtimes/ai-sdk/use-assistant-hook.mdx

@@ -1,195 +0,0 @@
----
-title: useAssistant Hook Integration
----
-
-## Overview
-
-Integration with the Vercel AI SDK UI's `useAssistant` hook.  
-This allows interaction with the OpenAI Assistants API.
-
-## Getting Started
-
-import { Steps, Step } from "fumadocs-ui/components/steps";
-
-<Steps>
-  <Step>
-  ### Create a Next.JS project
-
-```sh
-npx create-next-app@latest my-app
-cd my-app
-```
-
-  </Step>
-  <Step>
-
-### Install Vercel AI SDK and `@assistant-ui/react-ai-sdk`
-
-```sh npm2yarn
-npm install @assistant-ui/react @assistant-ui/react-ai-sdk ai openai
-```
-
-  </Step>
-  <Step>
-
-### Setup a backend route under `/api/assistant`
-
-`/app/api/assistant/route.ts`
-
-```tsx
-import { AssistantResponse } from "ai";
-import OpenAI from "openai";
-import type { Run } from "openai/resources/beta/threads/runs/runs";
-
-const openai = new OpenAI();
-
-// Allow streaming responses up to 30 seconds
-export const maxDuration = 30;
-
-export async function POST(req: Request) {
-  // Parse the request body
-  const input: {
-    threadId: string | null;
-    message: string;
-  } = await req.json();
-
-  // Create a thread if needed
-  const threadId = input.threadId ?? (await openai.beta.threads.create({})).id;
-
-  // Add a message to the thread
-  const createdMessage = await openai.beta.threads.messages.create(threadId, {
-    role: "user",
-    content: input.message,
-  });
-
-  return AssistantResponse(
-    { threadId, messageId: createdMessage.id },
-    async ({ forwardStream, sendDataMessage }) => {
-      // Run the assistant on the thread
-      const runStream = openai.beta.threads.runs.stream(threadId, {
-        assistant_id:
-          process.env.ASSISTANT_ID ??
-          (() => {
-            throw new Error("ASSISTANT_ID is not set");
-          })(),
-      });
-
-      // forward run status would stream message deltas
-      let runResult: Run = await forwardStream(runStream);
-
-      // status can be: queued, in_progress, requires_action, cancelling, cancelled, failed, completed, or expired
-      while (
-        runResult?.status === "requires_action" &&
-        runResult.required_action?.type === "submit_tool_outputs"
-      ) {
-        const tool_outputs =
-          runResult.required_action.submit_tool_outputs.tool_calls.map(
-            (toolCall: any) => {
-              const parameters = JSON.parse(toolCall.function.arguments);
-
-              switch (toolCall.function.name) {
-                // configure your tool calls here
-
-                default:
-                  throw new Error(
-                    `Unknown tool call function: ${toolCall.function.name}`,
-                  );
-              }
-            },
-          );
-
-        runResult = await forwardStream(
-          openai.beta.threads.runs.submitToolOutputsStream(
-            threadId,
-            runResult.id,
-            { tool_outputs },
-          ),
-        );
-      }
-    },
-  );
-}
-```
-
-  </Step>
-  <Step>
-
-### Define a `MyRuntimeProvider` component
-
-`@/app/MyRuntimeProvider.tsx`
-
-```tsx
-"use client";
-
-import { useAssistant } from "@ai-sdk/react";
-import { AssistantRuntimeProvider } from "@assistant-ui/react";
-import { useVercelUseAssistantRuntime } from "@assistant-ui/react-ai-sdk";
-
-export function MyRuntimeProvider({
-  children,
-}: Readonly<{
-  children: React.ReactNode;
-}>) {
-  const assistant = useAssistant({
-    api: "/api/assistant",
-  });
-
-  const runtime = useVercelUseAssistantRuntime(assistant);
-
-  return (
-    <AssistantRuntimeProvider runtime={runtime}>
-      {children}
-    </AssistantRuntimeProvider>
-  );
-}
-```
-
-  </Step>
-  <Step>
-
-### Wrap your app in `MyRuntimeProvider`
-
-`@/app/layout.tsx`
-
-```tsx {1,11,17}
-import { MyRuntimeProvider } from '@/app/MyRuntimeProvider';
-
-...
-
-export default function RootLayout({
-  children,
-}: Readonly<{
-  children: React.ReactNode;
-}>) {
-  return (
-    <MyRuntimeProvider>
-      <html lang="en">
-        <body className={inter.className}>
-          {children}
-        </body>
-      </html>
-    </MyRuntimeProvider>
-  )
-}
-```
-
-  </Step>
-</Steps>
-
-## Accessing AI SDK Messages
-
-You can use `getExternalStoreMessages` utility to convert `ThreadMessage`s back to `Message`s from AI SDK.
-
-```tsx
-const MyAssistantMessage = () => {
-  const aiSDKMessages = useMessage((m) => getExternalStoreMessages(m));
-  // ...
-};
-
-const WeatherToolUI = makeAssistantToolUI({
-  render: () => {
-    const aiSDKMessage = useMessagePart((p) => getExternalStoreMessages(p)[0]);
-    // ...
-  },
-});
-```