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

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]);
-    // ...
-  },
-});
-```

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

@@ -1,138 +0,0 @@
----
-title: useChat Hook Integration (Legacy)
----
-
-## Overview
-
-Integration with the Vercel AI SDK UI's `useChat` hook.  
-It allows integration with OpenAI, Anthropic, Mistral, Perplexity, AWS Bedrock, Azure, Google Gemini, Hugging Face, Fireworks, Cohere, LangChain, Replicate, Ollama, and more.
-
-## 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`
-
-```sh npm2yarn
-npm install @assistant-ui/react @assistant-ui/react-ai-sdk ai @ai-sdk/openai
-```
-
-  </Step>
-  <Step>
-
-### Setup a backend route under `/api/chat`
-
-`@/app/api/chat/route.ts`
-
-```tsx
-import { openai } from "@ai-sdk/openai";
-import { streamText } from "ai";
-
-export const maxDuration = 30;
-
-export async function POST(req: Request) {
-  const { messages } = await req.json();
-
-  const result = streamText({
-    model: openai("gpt-4o"),
-    messages: convertToCoreMessages(messages),
-  });
-
-  return result.toDataStreamResponse();
-}
-```
-
-  </Step>
-  <Step>
-
-### Define a `MyRuntimeProvider` component
-
-`@/app/MyRuntimeProvider.tsx`
-
-```tsx
-"use client";
-
-import { useChat } from "@ai-sdk/react";
-import { AssistantRuntimeProvider } from "@assistant-ui/react";
-import { useVercelUseChatRuntime } from "@assistant-ui/react-ai-sdk";
-
-export function MyRuntimeProvider({
-  children,
-}: Readonly<{
-  children: React.ReactNode;
-}>) {
-  const chat = useChat({
-    api: "/api/chat",
-  });
-
-  const runtime = useVercelUseChatRuntime(chat);
-
-  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 the `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]);
-    // ...
-  },
-});
-```