Vapi MCP Server

Instructions

Implementation Reference

• src/tools/assistant.ts:19-29 (registration)

  Registers the 'list_assistants' MCP tool on the server with empty input schema and handler that lists up to 10 Vapi assistants.

  server.tool(
    'list_assistants',
    'Lists all Vapi assistants',
    {},
    createToolHandler(async () => {
      //   console.log('list_assistants');
      const assistants = await vapiClient.assistants.list({ limit: 10 });
      //   console.log('assistants', assistants);
      return assistants.map(transformAssistantOutput);
    })
  );

• src/tools/assistant.ts:23-28 (handler)

  Handler logic for list_assistants: calls vapiClient.assistants.list({ limit: 10 }) and maps each to transformAssistantOutput.

  createToolHandler(async () => {
    //   console.log('list_assistants');
    const assistants = await vapiClient.assistants.list({ limit: 10 });
    //   console.log('assistants', assistants);
    return assistants.map(transformAssistantOutput);
  })

• src/tools/utils.ts:30-41 (helper)

  createToolHandler wraps the tool's raw handler function to return standardized ToolResponse and handle errors.

  export function createToolHandler<T>(
    handler: (params: T) => Promise<any>
  ): (params: T) => Promise<ToolResponse> {
    return async (params: T) => {
      try {
        const result = await handler(params);
        return createSuccessResponse(result);
      } catch (error) {
        return createErrorResponse(error);
      }
    };
  }

• src/transformers/index.ts:133-156 (helper)

  transformAssistantOutput converts Vapi Assistant object to the standardized AssistantOutputSchema format used in the response.

  export function transformAssistantOutput(
    assistant: Vapi.Assistant
  ): z.infer<typeof AssistantOutputSchema> {
    return {
      id: assistant.id,
      createdAt: assistant.createdAt,
      updatedAt: assistant.updatedAt,
      name: assistant.name || 'Vapi Assistant',
      llm: {
        provider: assistant.model?.provider || 'openai',
        model: assistant.model?.model || 'gpt-4o-mini',
      },
      voice: {
        provider: assistant.voice?.provider || '11labs',
        voiceId: getAssistantVoiceId(assistant.voice),
        model: getAssistantVoiceModel(assistant.voice) || 'eleven_turbo_v2_5',
      },
      transcriber: {
        provider: assistant.transcriber?.provider || 'deepgram',
        model: getAssistantTranscriberModel(assistant.transcriber) || 'nova-3',
      },
      toolIds: assistant.model?.toolIds || [],
    };
  }

• src/schemas/index.ts:179-195 (schema)

  AssistantOutputSchema defines the output structure for each assistant returned by list_assistants.

  export const AssistantOutputSchema = BaseResponseSchema.extend({
    name: z.string(),
    llm: z.object({
      provider: z.string(),
      model: z.string(),
    }),
    voice: z.object({
      provider: z.string(),
      voiceId: z.string(),
      model: z.string().optional(),
    }),
    transcriber: z.object({
      provider: z.string(),
      model: z.string(),
    }),
    toolIds: z.array(z.string()).optional(),
  });