npm - @assistant-ui/mcp-docs-server - Versions diffs - 0.1.30 → 0.1.31 - Mend

@assistant-ui/mcp-docs-server 0.1.30 → 0.1.31

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (208) hide show

package/.docs/raw/docs/runtimes/langserve.mdx DELETED Viewed

@@ -1,116 +0,0 @@
----
-title: LangChain LangServe
-description: Connect to LangServe endpoints via Vercel AI SDK integration.
----
-<Callout type="warning">
-  This integration has not been tested with AI SDK v6.
-</Callout>
-## Overview
-Integration with a LangServe server via Vercel AI SDK.
-## Getting Started
-<Steps>
-  <Step>
-  ### Create a Next.JS project
-```sh
-npx create-next-app@latest my-app
-cd my-app
-```
-  </Step>
-  <Step>
-### Install `@langchain/core`, AI SDK and `@assistant-ui/react`
-<InstallCommand npm={["@assistant-ui/react", "@assistant-ui/react-ai-sdk", "ai", "@ai-sdk/react", "@langchain/core"]} />
-  </Step>
-  <Step>
-### Setup a backend route under `/api/chat`
-```tsx title="@/app/api/chat/route.ts"
-import { RemoteRunnable } from "@langchain/core/runnables/remote";
-import { toDataStreamResponse } from "@ai-sdk/langchain";
-export const maxDuration = 30;
-export async function POST(req: Request) {
-  const { messages } = await req.json();
-  // TODO replace with your own langserve URL
-  const remoteChain = new RemoteRunnable({
-    url: "<YOUR_LANGSERVE_URL>",
-  });
-  const stream = await remoteChain.stream({
-    messages,
-  });
-  return toDataStreamResponse(stream);
-}
-```
-  </Step>
-  <Step>
-### Define a `MyRuntimeProvider` component
-```tsx twoslash include MyRuntimeProvider title="@/app/MyRuntimeProvider.tsx"
-// @filename: /app/MyRuntimeProvider.tsx
-// ---cut---
-"use client";
-import { AssistantRuntimeProvider } from "@assistant-ui/react";
-import { useChatRuntime } from "@assistant-ui/react-ai-sdk";
-export function MyRuntimeProvider({
-  children,
-}: Readonly<{
-  children: React.ReactNode;
-}>) {
-  const runtime = useChatRuntime();
-  return (
-    <AssistantRuntimeProvider runtime={runtime}>
-      {children}
-    </AssistantRuntimeProvider>
-  );
-}
-```
-  </Step>
-  <Step>
-### Wrap your app in `MyRuntimeProvider`
-```tsx twoslash title="@/app/layout.tsx"
-// @include: MyRuntimeProvider
-// @filename: /app/layout.tsx
-// ---cut---
-import type { ReactNode } from "react";
-import { MyRuntimeProvider } from "@/app/MyRuntimeProvider";
-export default function RootLayout({
-  children,
-}: Readonly<{
-  children: ReactNode;
-}>) {
-  return (
-    <html lang="en">
-      <body>
-        <MyRuntimeProvider>{children}</MyRuntimeProvider>
-      </body>
-    </html>
-  );
-}
-```
-  </Step>
-</Steps>

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

@@ -1,218 +0,0 @@
----
-title: Full-Stack Integration
-description: Integrate Mastra directly into Next.js API routes.
----
-Integrate Mastra directly into your Next.js application's API routes. This approach keeps your backend and frontend code within the same project.
-<Steps>
-<Step>
-### Initialize assistant-ui
-Start by setting up assistant-ui in your project. Run one of the following commands:
-```sh title="New Project"
-npx assistant-ui@latest create
-```
-```sh title="Existing Project"
-npx assistant-ui@latest init
-```
-This command installs necessary dependencies and creates basic configuration files, including a default chat API route.
-<Callout title="Need Help?">
-  For detailed setup instructions, including adding API keys, basic
-  configuration, and manual setup steps, please refer to the main [Getting
-  Started guide](/docs).
-</Callout>
-</Step>
-<Step>
-### Review Initial API Route
-The initialization command creates a basic API route at `app/api/chat/route.ts` (or `src/app/api/chat/route.ts`). It typically looks like this:
-```typescript title="app/api/chat/route.ts"
-import { openai } from "@ai-sdk/openai";
-import { streamText } from "ai";
-// Allow streaming responses up to 30 seconds
-export const maxDuration = 30;
-export async function POST(req: Request) {
-  const { messages } = await req.json();
-  const result = streamText({
-    model: openai("gpt-4o-mini"),
-    messages,
-  });
-  return result.toUIMessageStreamResponse();
-}
-```
-This default route uses the Vercel AI SDK directly with OpenAI. In the following steps, we will modify this route to integrate Mastra.
-</Step>
-<Step>
-### Install Mastra Packages
-Add the `@mastra/core` package and its peer dependency `zod` (which you can use later inside tools for example). Also add `@mastra/ai-sdk` to convert Mastra's stream to an AI SDK-compatible format:
-<InstallCommand npm={["@mastra/core@latest", "@mastra/ai-sdk@latest", "zod@latest"]} />
-</Step>
-<Step>
-### Configure Next.js
-To ensure Next.js correctly bundles your application when using Mastra directly in API routes, you need to configure `serverExternalPackages`.
-Update your `next.config.mjs` (or `next.config.js`) file to include `@mastra/*`:
-```js title="next.config.mjs"
-/** @type {import('next').NextConfig} */
-const nextConfig = {
-  serverExternalPackages: ["@mastra/*"],
-  // ... other configurations
-};
-export default nextConfig;
-```
-This tells Next.js to treat Mastra packages as external dependencies on the server-side.
-</Step>
-<Step>
-### Create Mastra Files
-Set up the basic folder structure for your Mastra configuration. Create a `mastra` folder (e.g., in your `src` or root directory) with the following structure:
-```txt title="Project Structure"
-/
-├── mastra/
-│   ├── agents/
-│   │   └── chefAgent.ts
-│   └── index.ts
-└── ... (rest of your project)
-```
-You can create these files and folders manually or use the following commands in your terminal:
-```bash
-mkdir -p mastra/agents
-touch mastra/index.ts mastra/agents/chefAgent.ts
-```
-These files will be used in the next steps to define your Mastra agent and configuration.
-</Step>
-<Step>
-### Define the Agent
-Now, let's define the behavior of our AI agent. Open the `mastra/agents/chefAgent.ts` file and add the following code:
-```typescript title="mastra/agents/chefAgent.ts"
-import { Agent } from "@mastra/core/agent";
-export const chefAgent = new Agent({
-  name: "chef-agent",
-  instructions:
-    "You are Michel, a practical and experienced home chef. " +
-    "You help people cook with whatever ingredients they have available.",
-  model: "openai/gpt-4o-mini",
-});
-```
-This code creates a new Mastra `Agent` named `chef-agent`.
-- `instructions`: Defines the agent's persona and primary goal.
-- `model`: Specifies the language model the agent will use (in this case, OpenAI's GPT-4o Mini via Mastra's model router).
-Make sure you have set up your OpenAI API key as described in the [Getting Started guide](/docs).
-</Step>
-<Step>
-### Register the Agent
-Next, register the agent with your Mastra instance. Open the `mastra/index.ts` file and add the following code:
-```typescript title="mastra/index.ts"
-import { Mastra } from "@mastra/core";
-import { chefAgent } from "./agents/chefAgent";
-export const mastra = new Mastra({
-  agents: { chefAgent },
-});
-```
-This code initializes Mastra and makes the `chefAgent` available for use in your application's API routes.
-</Step>
-<Step>
-### Modify the API Route
-Now, update your API route (`app/api/chat/route.ts`) to use the Mastra agent you just configured. Replace the existing content with the following:
-```typescript title="app/api/chat/route.ts"
-import { createUIMessageStreamResponse } from "ai";
-import { toAISdkFormat } from "@mastra/ai-sdk";
-import { mastra } from "@/mastra"; // Adjust the import path if necessary
-// Allow streaming responses up to 30 seconds
-export const maxDuration = 30;
-export async function POST(req: Request) {
-  // Extract the messages from the request body
-  const { messages } = await req.json();
-  // Get the chefAgent instance from Mastra
-  const agent = mastra.getAgent("chefAgent");
-  // Stream the response using the agent
-  const stream = await agent.stream(messages);
-  // Create a Response that streams the UI message stream to the client
-  return createUIMessageStreamResponse({
-    stream: toAISdkFormat(stream, { from: "agent" }),
-  });
-}
-```
-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 `createUIMessageStreamResponse()` and `toAISdkFormat()`.
-Your API route is now powered by Mastra!
-</Step>
-<Step>
-### Run the Application
-You're all set! Start your Next.js development server:
-```bash npm2yarn
-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!
-</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.
-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 DELETED Viewed

@@ -1,18 +0,0 @@
----
-title: Overview
-description: TypeScript agent framework for AI applications with tools and workflows.
----
-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
-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)
-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.

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

@@ -1,217 +0,0 @@
----
-title: Separate Server Integration
-description: Run Mastra as a standalone server connected to your frontend.
----
-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>
-<Step>
-### 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.
-Navigate to your chosen parent directory in the terminal and run the Mastra create command:
-```bash
-npx create-mastra@latest
-```
-This command will launch an interactive wizard to help you scaffold a new Mastra project, including prompting you for a project name and setting up basic configurations. Follow the prompts to create your server project. For more detailed setup instructions, refer to the [official Mastra installation guide](https://mastra.ai/docs/getting-started/installation).
-Once the setup is complete, navigate into your new Mastra project directory (the name you provided during the setup):
-```bash
-cd your-mastra-server-directory # Replace with the actual directory name
-```
-In the next steps you'll need to use the `@mastra/ai-sdk` package. Add it to your Mastra project:
-<InstallCommand npm={["@mastra/ai-sdk@latest"]} />
-You now have a basic Mastra server project ready.
-<Callout title="API Keys">
-  Ensure you have configured your environment variables (e.g., `OPENAI_API_KEY`)
-  within this Mastra server project, typically in a `.env.development` file, as
-  required by the models you use. The `create-mastra` wizard might prompt you
-  for some keys, but ensure all necessary keys for your chosen models are
-  present.
-</Callout>
-</Step>
-<Step>
-### Define the Agent
-Next, let's define an agent within your Mastra server project. We'll create a `chefAgent` similar to the one used in the full-stack guide.
-Open or create the agent file (e.g., `src/mastra/agents/chefAgent.ts` within your Mastra project) and add the following code:
-```typescript title="src/mastra/agents/chefAgent.ts"
-import { Agent } from "@mastra/core/agent";
-export const chefAgent = new Agent({
-  name: "chef-agent",
-  instructions:
-    "You are Michel, a practical and experienced home chef. " +
-    "You help people cook with whatever ingredients they have available.",
-  model: "openai/gpt-4o-mini",
-});
-```
-This defines the agent's behavior, but it's not yet active in the Mastra server.
-</Step>
-<Step>
-### Register the Agent
-Now, you need to register the `chefAgent` with your Mastra instance so the server knows about it. Open your main Mastra configuration file (this is often `src/mastra/index.ts` in projects created with `create-mastra`).
-Import the `chefAgent` and add it to the `agents` object when initializing Mastra:
-```typescript title="src/mastra/index.ts"
-import { Mastra } from "@mastra/core";
-import { chefAgent } from "./agents/chefAgent"; // Adjust path if necessary
-export const mastra = new Mastra({
-  agents: { chefAgent },
-});
-```
-Make sure you adapt this code to fit the existing structure of your `src/mastra/index.ts` file generated by `create-mastra`. The key is to import your agent and include it in the `agents` configuration object.
-</Step>
-<Step>
-### Register the Chat Route
-Still inside `src/mastra/index.ts`, register a chat route for the `chefAgent` now. You can do this by using `chatRoute()` from `@mastra/ai-sdk`. You need to place this inside `server.apiRoutes` of your Mastra configuration:
-```typescript title="src/mastra/index.ts" {3,7-13}
-import { Mastra } from "@mastra/core";
-import { chefAgent } from "./agents/chefAgent";
-import { chatRoute } from "@mastra/ai-sdk";
-export const mastra = new Mastra({
-  agents: { chefAgent },
-  server: {
-    apiRoutes: [
-      chatRoute({
-        path: "/chat/:agentId",
-      }),
-    ],
-  },
-});
-```
-Make sure you adapt this code to fit the existing structure of your `src/mastra/index.ts` file generated by `create-mastra`. This will make all agents available in AI SDK-compatible formats, including the `chefAgent` at the endpoint `/chat/chefAgent`.
-</Step>
-<Step>
-### Run the Mastra Server
-With the agent defined and registered, start the Mastra development server:
-```bash npm2yarn
-npm run dev
-```
-By default, the Mastra server will run on `http://localhost:4111`. 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
-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:
-```sh title="New Project"
-npx assistant-ui@latest create
-```
-```sh title="Existing Project"
-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`).
-<Callout title="Need Help?">
-  For detailed setup instructions for assistant-ui, including manual setup
-  steps, please refer to the main [Getting Started
-  guide](/docs).
-</Callout>
-In the next step, we will configure this frontend to communicate with the separate Mastra server instead of using the default API route.
-</Step>
-<Step>
-### 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.
-Open the file in your assistant-ui frontend project that contains the `useChatRuntime` hook (usually `app/assistant.tsx` or `src/app/assistant.tsx`). Find the `useChatRuntime` hook and change the `api` property to the full URL of your Mastra agent's stream endpoint:
-```tsx {8} title="app/assistant.tsx"
-"use client";
-// Rest of the imports...
-export const Assistant = () => {
-  const runtime = useChatRuntime({
-    transport: new AssistantChatTransport({
-      api: "http://localhost:4111/chat/chefAgent",
-    }),
-  });
-  // Rest of the component...
-};
-```
-Replace `"http://localhost:4111/chat/chefAgent"` 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.
-<Callout title="Delete Default API Route">
-  Since the frontend no longer uses the local `/api/chat` route created by the
-  `init` command, you can safely delete the `app/api/chat/route.ts` (or
-  `src/app/api/chat/route.ts`) file from your frontend project.
-</Callout>
-</Step>
-<Step>
-### Run the Frontend Application
-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:
-```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`.
-</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.
-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).