User Context

import { error, text } from "mcp-use";
import { z } from "zod";

server.tool(
  {
    name: "create_document",
    description: "Create a document owned by the authenticated user.",
    inputSchema: z.object({
      title: z.string(),
      content: z.string(),
    }),
  },
  async ({ title, content }, ctx) => {
    if (!ctx.auth) {
      return error("Unauthorized");
    }

    const document = await db.documents.create({
      title,
      content,
      createdBy: ctx.auth.user.userId,
    });

    return text(`Created document ${document.id}.`);
  },
);

const { user } = ctx.auth;

const profile = {
  userId: user.userId,
  email: user.email,
  name: user.name,
  picture: user.picture,
};

import { error, text } from "mcp-use";

server.tool(
  {
    name: "delete_document",
    description: "Delete a document when the caller has permission.",
  },
  async ({ documentId }, ctx) => {
    if (!ctx.auth) {
      return error("Unauthorized");
    }

    if (!ctx.auth.permissions.includes("documents:delete")) {
      return error("Forbidden: documents:delete permission required");
    }

    await db.documents.delete({ id: documentId });
    return text("Document deleted.");
  },
);

import { error, object } from "mcp-use";

server.tool(
  {
    name: "list_documents",
    description: "List documents for the authenticated organization.",
  },
  async (_args, ctx) => {
    if (!ctx.auth) {
      return error("Unauthorized");
    }

    const organizationId = ctx.auth.user.organization_id as string | undefined;

    if (!organizationId) {
      return error("Organization context required.");
    }

    const documents = await db.documents.findMany({
      where: { organizationId },
    });

    return object({ documents });
  },
);

import { MCPServer } from "mcp-use";
import { oauthCustomProvider } from "mcp-use/oauth";

const server = new MCPServer({
  name: "secure-server",
  version: "1.0.0",
  oauth: oauthCustomProvider({
    issuer: "https://auth.example.com",
    authEndpoint: "https://auth.example.com/oauth/authorize",
    tokenEndpoint: "https://auth.example.com/oauth/token",
    async verifyToken(token) {
      return verifyTokenWithYourProvider(token);
    },
    getUserInfo(payload) {
      return {
        userId: payload.sub as string,
        email: payload.email as string | undefined,
        organizationId: payload["https://example.com/org_id"],
        roles: (payload["https://example.com/roles"] as string[]) ?? [],
      };
    },
  }),
});