MCP服务器部署工具

cd app
cp .env.example .env.local   # fill in your credentials
npm install
vercel deploy

// src/servers/myapi/index.ts
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
import { z } from 'zod';
import type { MCPUserContext, MCPServerDefinition } from '../../types';

// 1. Define input schemas
const SearchSchema = z.object({
  query: z.string().min(1),
  limit: z.number().int().positive().max(100).optional().default(10),
});

// 2. Create server factory
export function createMyApiServer(context?: MCPUserContext): Server {
  const server = new Server(
    { name: 'myapi', version: '1.0.0' },
    { capabilities: { tools: {} } }
  );

  // 3. List available tools
  server.setRequestHandler(ListToolsRequestSchema, async () => ({
    tools: [
      {
        name: 'myapi_search',
        description: 'Search my API for results',
        inputSchema: {
          type: 'object' as const,
          properties: {
            query: { type: 'string' as const, description: 'Search query' },
            limit: { type: 'number' as const, description: 'Max results', default: 10 },
          },
          required: ['query'],
        },
        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
      },
    ],
  }));

  // 4. Handle tool calls
  server.setRequestHandler(CallToolRequestSchema, async (request) => {
    const { name, arguments: args } = request.params;
    try {
      switch (name) {
        case 'myapi_search': {
          const input = SearchSchema.parse(args);
          const resp = await fetch(`https://api.example.com/search?q=${encodeURIComponent(input.query)}&limit=${input.limit}`);
          const data = await resp.json();
          return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
        }
        default:
          throw new Error(`Unknown tool: ${name}`);
      }
    } catch (error) {
      return {
        content: [{ type: 'text', text: JSON.stringify({ error: (error as Error).message }, null, 2) }],
        isError: true,
      };
    }
  });

  return server;
}

// 5. Export the server definition
export const myapi: MCPServerDefinition = {
  slug: 'myapi',
  name: 'My API MCP Server',
  createServer: createMyApiServer,
  auth: { scopes: [] }, // Add OAuth scopes if your API needs them
};

import { createMCPApp, createGoogleAuthProvider, gmail, myapi } from '@n47vc/mcp';

export default createMCPApp({
  secret: process.env.MCP_SECRET!,
  authProvider: createGoogleAuthProvider({
    clientId: process.env.GOOGLE_CLIENT_ID!,
    clientSecret: process.env.GOOGLE_CLIENT_SECRET!,
  }),
  servers: [gmail, myapi],
});

interface AuthProviderConfig {
  id: string;
  name: string;
  getAuthorizationUrl(callbackUrl: string, state: string, scopes: string[]): string;
  exchangeCode(code: string, callbackUrl: string): Promise<AuthProviderTokens>;
  refreshAccessToken(refreshToken: string): Promise<{ access_token: string } | undefined>;
  getBaseScopes(): string[];
}