MCP 기반 멀티모달 Claude: 이미지, 음성, 문서를 통합한 지능형 비서 구축하기

오늘날 기업 환경에서는 다양한 형태의 데이터를 효과적으로 처리하고 분석할 수 있는 AI 시스템의 필요성이 점점 커지고 있습니다. Claude와 같은 고급 언어 모델은 텍스트 기반 작업에서 뛰어난 능력을 보여주지만, 실제 업무 환경에서는 이미지, 음성, 문서 등 다양한 형태의 데이터를 함께 처리할 수 있어야 합니다. 이번 포스팅에서는 MCP(Model Context Protocol)를 확장하여 Claude를 멀티모달 지능형 비서로 발전시키는 방법을 살펴보겠습니다.

멀티모달 AI의 필요성과 이점

우선, 멀티모달 AI가 왜 중요한지 이해해 봅시다. 멀티모달이란 여러 형태(모달리티)의 데이터를 처리할 수 있는 능력을 의미합니다. 인간은 자연스럽게 텍스트, 이미지, 소리, 동작 등 다양한 형태의 정보를 동시에 처리하고 통합합니다. 회의에 참석할 때, 우리는 말을 들으면서 발표 자료를 보고, 참석자의 표정을 읽고, 메모를 작성합니다. 이처럼 여러 감각 정보를 통합하는 능력이 진정한 지능의 핵심입니다.

멀티모달 Claude를 구축하면 다음과 같은 이점이 있습니다:

1. 포괄적인 정보 처리: 텍스트만으로는 전달하기 어려운 복잡한 정보를 이미지, 음성 등을 통해 종합적으로 이해합니다.
2. 향상된 접근성: 시각 장애인을 위한 이미지 설명, 청각 장애인을 위한 음성 텍스트 변환 등 다양한 사용자 요구를 지원합니다.
3. 효율적인 업무 자동화: 문서 분석, 회의 요약, 멀티미디어 콘텐츠 처리 등 복잡한 업무를 자동화할 수 있습니다.
4. 자연스러운 상호작용: 인간 비서와 유사하게 다양한 채널을 통해 의사소통하고 작업을 수행할 수 있습니다.

멀티모달 MCP 아키텍처 설계

멀티모달 Claude를 구현하기 위해서는 기존 MCP 아키텍처를 확장해야 합니다. 이를 위한 전체적인 시스템 설계를 살펴보겠습니다.

1. 멀티모달 데이터 처리 파이프라인

먼저, 다양한 형태의 데이터를 처리할 수 있는 파이프라인을 구축해야 합니다. 각 모달리티별로 특화된 처리 과정이 필요합니다:

• 이미지 처리 파이프라인: 이미지 인식, 객체 감지, OCR(광학 문자 인식) 등
• 음성 처리 파이프라인: 음성 인식(STT), 음성 합성(TTS), 화자 식별 등
• 문서 처리 파이프라인: PDF, Word, Excel 등 다양한 문서 형식 파싱 및 분석

이러한 파이프라인을 MCP 서버에 통합하여 Claude가 다양한 형태의 데이터를 처리할 수 있도록 합니다.

// multimodalHandler.js - 멀티모달 데이터 처리 핸들러
const express = require('express');
const multer = require('multer');
const fs = require('fs-extra');
const path = require('path');
const { v4: uuidv4 } = require('uuid');
const logger = require('../utils/logger');

// 외부 AI 서비스 클라이언트 불러오기
const imageProcessor = require('../services/imageProcessor');
const speechProcessor = require('../services/speechProcessor');
const documentProcessor = require('../services/documentProcessor');

// 파일 업로드 설정
const storage = multer.diskStorage({
  destination: (req, file, cb) => {
    const uploadDir = path.join(__dirname, '../uploads');
    fs.ensureDirSync(uploadDir);
    cb(null, uploadDir);
  },
  filename: (req, file, cb) => {
    const uniqueId = uuidv4();
    const ext = path.extname(file.originalname);
    cb(null, `${uniqueId}${ext}`);
  }
});

const upload = multer({
  storage,
  limits: { fileSize: 50 * 1024 * 1024 }, // 50MB 제한
  fileFilter: (req, file, cb) => {
    // 허용되는 파일 형식 검사
    const allowedTypes = [
      // 이미지
      'image/jpeg', 'image/png', 'image/gif', 'image/webp', 'image/svg+xml',
      // 오디오
      'audio/mpeg', 'audio/wav', 'audio/ogg', 'audio/webm',
      // 문서
      'application/pdf', 'application/msword',
      'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
      'application/vnd.ms-excel',
      'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
      'application/vnd.ms-powerpoint',
      'application/vnd.openxmlformats-officedocument.presentationml.presentation',
      'text/plain', 'text/csv'
    ];

    if (allowedTypes.includes(file.mimetype)) {
      cb(null, true);
    } else {
      cb(new Error('지원되지 않는 파일 형식입니다.'), false);
    }
  }
});

// 파일 형식별 처리 함수 매핑
const processFile = async (filePath, mimeType) => {
  try {
    // 이미지 처리
    if (mimeType.startsWith('image/')) {
      return await imageProcessor.processImage(filePath);
    }

    // 오디오 처리
    if (mimeType.startsWith('audio/')) {
      return await speechProcessor.processAudio(filePath);
    }

    // 문서 처리
    if (mimeType.startsWith('application/') || mimeType.startsWith('text/')) {
      return await documentProcessor.processDocument(filePath, mimeType);
    }

    throw new Error('처리할 수 없는 파일 형식입니다.');
  } catch (error) {
    logger.error('파일 처리 실패', { error: error.message, filePath, mimeType });
    throw error;
  }
};

// 멀티모달 파일 처리 엔드포인트
const processMultimodalFile = async (req, res) => {
  try {
    if (!req.file) {
      return res.status(400).json({ error: '파일이 업로드되지 않았습니다.' });
    }

    const filePath = req.file.path;
    const mimeType = req.file.mimetype;

    logger.info('멀티모달 파일 처리 시작', { filename: req.file.originalname, mimeType });

    // 파일 처리 및 결과 반환
    const result = await processFile(filePath, mimeType);

    // 처리 결과 반환
    return res.json({
      success: true,
      originalName: req.file.originalname,
      mimeType,
      result
    });

  } catch (error) {
    logger.error('멀티모달 파일 처리 실패', { error: error.message });
    return res.status(500).json({ error: `파일 처리 중 오류가 발생했습니다: ${error.message}` });
  }
};

// 멀티파트 요청 처리 엔드포인트
const processMultipart = async (req, res) => {
  try {
    // 텍스트 및 파일이 혼합된 요청 처리
    const { text, context } = req.body;
    const fileResults = [];

    // 업로드된 파일 처리
    if (req.files && req.files.length > 0) {
      for (const file of req.files) {
        const result = await processFile(file.path, file.mimetype);
        fileResults.push({
          originalName: file.originalname,
          mimeType: file.mimetype,
          result
        });
      }
    }

    // 종합 결과 생성
    const integratedContext = {
      text: text || '',
      context: context ? JSON.parse(context) : {},
      files: fileResults
    };

    // Claude에 통합 컨텍스트 전달 로직
    // (실제 구현은 Claude API 연동 방식에 따라 달라짐)

    return res.json({
      success: true,
      integratedContext
    });

  } catch (error) {
    logger.error('멀티파트 요청 처리 실패', { error: error.message });
    return res.status(500).json({ error: `요청 처리 중 오류가 발생했습니다: ${error.message}` });
  }
};

module.exports = {
  singleUpload: upload.single('file'),
  multiUpload: upload.array('files', 10),
  processMultimodalFile,
  processMultipart
};

위 코드는 멀티모달 데이터를 처리하기 위한 기본적인 핸들러입니다. 각 파일 형식에 따라 적절한 처리 서비스로 전달하고, 처리 결과를 클라이언트에 반환합니다. 이제 각 모달리티별 처리 서비스를 구현해 보겠습니다.

2. 이미지 처리 서비스 구현

이미지 처리 서비스는 이미지 인식, 객체 감지, OCR 등의 기능을 제공합니다. 이를 위해 외부 AI 서비스(예: Google Vision API, Azure Computer Vision 등)를 활용할 수 있습니다.

// services/imageProcessor.js - 이미지 처리 서비스
const fs = require('fs');
const axios = require('axios');
const FormData = require('form-data');
const logger = require('../utils/logger');
require('dotenv').config();

// 외부 이미지 인식 API 설정
const VISION_API_URL = process.env.VISION_API_URL;
const VISION_API_KEY = process.env.VISION_API_KEY;

// OCR 서비스 설정
const OCR_API_URL = process.env.OCR_API_URL;
const OCR_API_KEY = process.env.OCR_API_KEY;

// 이미지 분석 (객체 감지, 장면 인식 등)
const analyzeImage = async (filePath) => {
  try {
    const formData = new FormData();
    formData.append('image', fs.createReadStream(filePath));

    const response = await axios.post(`${VISION_API_URL}/analyze`, formData, {
      headers: {
        ...formData.getHeaders(),
        'x-api-key': VISION_API_KEY,
        'Content-Type': 'multipart/form-data'
      },
      params: {
        features: 'objects,tags,description,faces',
        language: 'ko'
      }
    });

    return response.data;
  } catch (error) {
    logger.error('이미지 분석 실패', { error: error.message, filePath });
    throw new Error(`이미지 분석 중 오류 발생: ${error.message}`);
  }
};

// 이미지 내 텍스트 추출 (OCR)
const extractTextFromImage = async (filePath) => {
  try {
    const formData = new FormData();
    formData.append('image', fs.createReadStream(filePath));

    const response = await axios.post(`${OCR_API_URL}/read`, formData, {
      headers: {
        ...formData.getHeaders(),
        'x-api-key': OCR_API_KEY,
        'Content-Type': 'multipart/form-data'
      },
      params: {
        language: 'ko,en',
        detectOrientation: 'true'
      }
    });

    return response.data;
  } catch (error) {
    logger.error('OCR 처리 실패', { error: error.message, filePath });
    throw new Error(`OCR 처리 중 오류 발생: ${error.message}`);
  }
};

// 차트 및 그래프 해석
const interpretChart = async (filePath) => {
  try {
    // 차트 인식 및 데이터 추출 로직
    // (실제 구현은 사용하는 서비스에 따라 달라짐)

    return { chartType: 'detected_automatically', data: [] };
  } catch (error) {
    logger.error('차트 해석 실패', { error: error.message, filePath });
    throw new Error(`차트 해석 중 오류 발생: ${error.message}`);
  }
};

// 이미지 처리 통합 함수
const processImage = async (filePath) => {
  try {
    // 이미지 분석 및 OCR 동시 수행
    const [analysisResult, ocrResult] = await Promise.all([
      analyzeImage(filePath),
      extractTextFromImage(filePath)
    ]);

    // 차트로 판단되는 경우 차트 해석 추가 수행
    let chartData = null;
    if (analysisResult.tags.some(tag => 
      ['chart', 'graph', 'diagram', 'plot'].includes(tag.name.toLowerCase()) && 
      tag.confidence > 0.7
    )) {
      chartData = await interpretChart(filePath);
    }

    // 결과 통합
    return {
      description: analysisResult.description.captions[0]?.text || '이미지 설명을 생성할 수 없습니다.',
      tags: analysisResult.tags.map(tag => tag.name),
      objects: analysisResult.objects.map(obj => ({
        name: obj.object,
        confidence: obj.confidence,
        rectangle: obj.rectangle
      })),
      faces: analysisResult.faces.length,
      text: ocrResult.text,
      chartData
    };

  } catch (error) {
    logger.error('이미지 처리 통합 실패', { error: error.message, filePath });
    throw error;
  }
};

module.exports = {
  processImage,
  analyzeImage,
  extractTextFromImage,
  interpretChart
};

위 코드는 이미지 처리를 위한 핵심 기능을 구현합니다. 실제 환경에서는 이미지 인식과 OCR을 위한 외부 API를 연동해야 합니다. Google Cloud Vision API, Microsoft Azure Computer Vision, Amazon Rekognition 등의 서비스를 활용할 수 있습니다.

3. 음성 처리 서비스 구현

음성 처리 서비스는 음성 인식(STT)과 음성 합성(TTS) 기능을 제공합니다. 이를 통해 Claude가 음성 명령을 이해하고 음성으로 응답할 수 있습니다.

// services/speechProcessor.js - 음성 처리 서비스
const fs = require('fs');
const axios = require('axios');
const FormData = require('form-data');
const ffmpeg = require('fluent-ffmpeg');
const logger = require('../utils/logger');
require('dotenv').config();

// 외부 음성 인식 API 설정
const STT_API_URL = process.env.STT_API_URL;
const STT_API_KEY = process.env.STT_API_KEY;

// 외부 음성 합성 API 설정
const TTS_API_URL = process.env.TTS_API_URL;
const TTS_API_KEY = process.env.TTS_API_KEY;

// 오디오 포맷 변환 (STT를 위한 전처리)
const convertAudioFormat = (inputPath, outputPath, format = 'wav') => {
  return new Promise((resolve, reject) => {
    ffmpeg(inputPath)
      .output(outputPath)
      .audioCodec('pcm_s16le')
      .audioChannels(1)
      .audioFrequency(16000)
      .on('end', () => resolve(outputPath))
      .on('error', (err) => reject(err))
      .run();
  });
};

// 음성 인식 (STT)
const speechToText = async (filePath) => {
  try {
    // 오디오 파일 전처리 (WAV 포맷으로 변환)
    const wavPath = `${filePath}.wav`;
    await convertAudioFormat(filePath, wavPath);

    // STT API 호출
    const formData = new FormData();
    formData.append('audio', fs.createReadStream(wavPath));

    const response = await axios.post(`${STT_API_URL}/recognize`, formData, {
      headers: {
        ...formData.getHeaders(),
        'x-api-key': STT_API_KEY,
        'Content-Type': 'multipart/form-data'
      },
      params: {
        language: 'ko-KR',
        model: 'default',
        enableAutomaticPunctuation: 'true',
        enableSpeakerDiarization: 'true',
        diarizationSpeakerCount: 2
      }
    });

    // 임시 파일 삭제
    fs.unlinkSync(wavPath);

    return {
      transcript: response.data.results.map(result => result.alternatives[0].transcript).join(' '),
      confidence: response.data.results[0]?.alternatives[0]?.confidence || 0,
      speakerSegments: response.data.speakerSegments || []
    };
  } catch (error) {
    logger.error('음성 인식 실패', { error: error.message, filePath });
    throw new Error(`음성 인식 중 오류 발생: ${error.message}`);
  }
};

// 음성 감정 분석
const analyzeVoiceEmotion = async (filePath) => {
  try {
    // 감정 분석 API 호출 로직
    // (실제 구현은 사용하는 서비스에 따라 달라짐)

    return {
      primaryEmotion: 'neutral',
      emotions: {
        neutral: 0.7,
        happy: 0.2,
        sad: 0.05,
        angry: 0.03,
        surprised: 0.02
      }
    };
  } catch (error) {
    logger.error('음성 감정 분석 실패', { error: error.message, filePath });
    return { primaryEmotion: 'unknown', emotions: {} };
  }
};

// 음성 합성 (TTS)
const textToSpeech = async (text, options = {}) => {
  try {
    const defaultOptions = {
      language: 'ko-KR',
      voice: 'female',
      speed: 1.0,
      pitch: 0,
      outputFormat: 'mp3'
    };

    const mergedOptions = { ...defaultOptions, ...options };

    const response = await axios.post(`${TTS_API_URL}/synthesize`, {
      text,
      ...mergedOptions
    }, {
      headers: {
        'x-api-key': TTS_API_KEY,
        'Content-Type': 'application/json'
      },
      responseType: 'arraybuffer'
    });

    // 임시 파일로 저장
    const outputPath = `./uploads/tts_${Date.now()}.${mergedOptions.outputFormat}`;
    fs.writeFileSync(outputPath, response.data);

    return {
      audioFile: outputPath,
      mimeType: `audio/${mergedOptions.outputFormat}`,
      duration: 0 // 실제 구현에서는 오디오 길이 계산 필요
    };
  } catch (error) {
    logger.error('음성 합성 실패', { error: error.message, text: text.substring(0, 50) });
    throw new Error(`음성 합성 중 오류 발생: ${error.message}`);
  }
};

// 오디오 파일 처리 통합 함수
const processAudio = async (filePath) => {
  try {
    // 음성 인식 및 감정 분석 수행
    const [transcriptionResult, emotionResult] = await Promise.all([
      speechToText(filePath),
      analyzeVoiceEmotion(filePath)
    ]);

    // 결과 통합
    return {
      transcript: transcriptionResult.transcript,
      confidence: transcriptionResult.confidence,
      speakerSegments: transcriptionResult.speakerSegments,
      emotion: emotionResult.primaryEmotion,
      emotionScores: emotionResult.emotions
    };

  } catch (error) {
    logger.error('오디오 처리 통합 실패', { error: error.message, filePath });
    throw error;
  }
};

module.exports = {
  processAudio,
  speechToText,
  textToSpeech,
  analyzeVoiceEmotion
};

음성 처리 서비스에서는 외부 API를 활용하여 STT와 TTS 기능을 구현합니다. Google Cloud Speech-to-Text, Amazon Transcribe, Microsoft Azure Speech Services 등의 서비스를 사용할 수 있습니다. 또한 ffmpeg을 사용하여 다양한 오디오 형식을 처리하므로 이를 서버에 설치해야 합니다.

4. 문서 처리 서비스 구현

문서 처리 서비스는 PDF, Word, Excel 등 다양한 문서 형식을 분석하고 텍스트를 추출하는 기능을 제공합니다.

// services/documentProcessor.js - 문서 처리 서비스
const fs = require('fs');
const path = require('path');
const mammoth = require('mammoth');
const pdf = require('pdf-parse');
const xlsx = require('xlsx');
const csv = require('csv-parser');
const logger = require('../utils/logger');

// Word 문서 처리
const processWordDocument = async (filePath) => {
  try {
    // .docx 파일에서 텍스트 및 요소 추출
    const result = await mammoth.extractRawText({ path: filePath });
    const text = result.value;

    // 문서 구조 및 스타일 정보 추출 (옵션)
    const styleMap = await mammoth.readStyleMap(filePath);

    // 이미지 추출 (옵션)
    const imageResult = await mammoth.convertToHtml({
      path: filePath,
      convertImage: mammoth.images.imgElement()
    });

    return {
      text,
      metadata: {
        format: 'docx',
        hasImages: imageResult.messages.some(msg => msg.type === 'warning' && msg.message.includes('image')),
        styleInfo: styleMap ? true : false
      }
    };
  } catch (error) {
    logger.error('Word 문서 처리 실패', { error: error.message, filePath });
    throw new Error(`Word 문서 처리 중 오류 발생: ${error.message}`);
  }
};

// PDF 문서 처리
const processPdfDocument = async (filePath) => {
  try {
    const dataBuffer = fs.readFileSync(filePath);
    const data = await pdf(dataBuffer);

    return {
      text: data.text,
      metadata: {
        format: 'pdf',
        pageCount: data.numpages,
        info: data.info,
        version: data.version
      }
    };
  } catch (error) {
    logger.error('PDF 문서 처리 실패', { error: error.message, filePath });
    throw new Error(`PDF 문서 처리 중 오류 발생: ${error.message}`);
  }
};

// Excel 문서 처리
const processExcelDocument = async (filePath) => {
  try {
    // 워크북 로드
    const workbook = xlsx.readFile(filePath);

    // 모든 시트 데이터 추출
    const result = {};

    // 각 시트 처리
    workbook.SheetNames.forEach((sheetName) => {
      const worksheet = workbook.Sheets[sheetName];

      // 시트 데이터를 JSON으로 변환
      const sheetData = xlsx.utils.sheet_to_json(worksheet, { header: 1 });

      // 헤더 행 식별 (첫 번째 행을 헤더로 가정)
      const headers = sheetData[0] || [];

      // 데이터 행 변환
      const rows = sheetData.slice(1).map(row => {
        const rowData = {};
        headers.forEach((header, index) => {
          rowData[header] = row[index];
        });
        return rowData;
      });

      result[sheetName] = {
        headers,
        rows,
        rowCount: rows.length,
        columnCount: headers.length
      };
    });

    return {
      sheets: result,
      metadata: {
        format: 'xlsx',
        sheetCount: workbook.SheetNames.length,
        sheetNames: workbook.SheetNames
      }
    };
  } catch (error) {
    logger.error('Excel 문서 처리 실패', { error: error.message, filePath });
    throw new Error(`Excel 문서 처리 중 오류 발생: ${error.message}`);
  }
};

// CSV 문서 처리
const processCsvDocument = async (filePath) => {
  return new Promise((resolve, reject) => {
    try {
      const rows = [];
      let headers = [];
      let rowCount = 0;

      fs.createReadStream(filePath)
        .pipe(csv())
        .on('headers', (headerRow) => {
          headers = headerRow;
        })
        .on('data', (row) => {
          rows.push(row);
          rowCount++;
        })
        .on('end', () => {
          resolve({
            headers,
            rows,
            metadata: {
              format: 'csv',
              rowCount,
              columnCount: headers.length
            }
          });
        })
        .on('error', (error) => {
          logger.error('CSV 파싱 오류', { error: error.message, filePath });
          reject(new Error(`CSV 파싱 중 오류 발생: ${error.message}`));
        });
    } catch (error) {
      logger.error('CSV 문서 처리 실패', { error: error.message, filePath });
      reject(new Error(`CSV 문서 처리 중 오류 발생: ${error.message}`));
    }
  });
};

// 일반 텍스트 파일 처리
const processTextDocument = async (filePath) => {
  try {
    const text = fs.readFileSync(filePath, 'utf8');

    return {
      text,
      metadata: {
        format: 'txt',
        lineCount: text.split('\n').length,
        charCount: text.length,
        wordCount: text.split(/\s+/).filter(Boolean).length
      }
    };
  } catch (error) {
    logger.error('텍스트 파일 처리 실패', { error: error.message, filePath });
    throw new Error(`텍스트 파일 처리 중 오류 발생: ${error.message}`);
  }
};

// 문서 처리 통합 함수
const processDocument = async (filePath, mimeType) => {
  try {
    // 파일 확장자 확인
    const ext = path.extname(filePath).toLowerCase();

    // 문서 유형에 따라 적절한 처리 함수 호출
    if (mimeType === 'application/pdf' || ext === '.pdf') {
      return await processPdfDocument(filePath);
    } else if (mimeType === 'application/msword' || 
               mimeType === 'application/vnd.openxmlformats-officedocument.wordprocessingml.document' ||
```javascript
// services/documentProcessor.js (continued)
               ext === '.doc' || ext === '.docx') {
      return await processWordDocument(filePath);
    } else if (mimeType === 'application/vnd.ms-excel' || 
               mimeType === 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' ||
               ext === '.xls' || ext === '.xlsx') {
      return await processExcelDocument(filePath);
    } else if (mimeType === 'text/csv' || ext === '.csv') {
      return await processCsvDocument(filePath);
    } else if (mimeType === 'text/plain' || ext === '.txt') {
      return await processTextDocument(filePath);
    } else {
      throw new Error(`지원되지 않는 문서 형식: ${mimeType || ext}`);
    }
  } catch (error) {
    logger.error('문서 처리 통합 실패', { error: error.message, filePath, mimeType });
    throw error;
  }
};

module.exports = {
  processDocument,
  processWordDocument,
  processPdfDocument,
  processExcelDocument,
  processCsvDocument,
  processTextDocument
};

문서 처리 서비스는 다양한 형식의 문서를 파싱하고 텍스트 및 구조 정보를 추출합니다. 이를 위해 여러 라이브러리를 활용하며, 문서 유형에 따라 적절한 처리 함수를 호출합니다.

통합 인터페이스: 멀티모달 MCP 서버 구현

지금까지 구현한 개별 서비스들을 통합하여 멀티모달 MCP 서버를 구축해 보겠습니다. 이 서버는 Claude가 다양한 형태의 데이터를 처리하고 응답할 수 있는 인터페이스를 제공합니다.

// index.js - 멀티모달 MCP 서버 메인 파일
const express = require('express');
const cors = require('cors');
const logger = require('./utils/logger');
const { authenticateRequest } = require('./utils/auth');
const multimodalHandler = require('./handlers/multimodalHandler');

require('dotenv').config();

// Express 앱 생성
const app = express();
const PORT = process.env.PORT || 3000;

// 미들웨어 설정
app.use(cors());
app.use(express.json({ limit: '50mb' }));
app.use(express.urlencoded({ extended: true, limit: '50mb' }));

// 서버 상태 확인 엔드포인트
app.get('/health', (req, res) => {
  res.json({ status: 'ok', timestamp: new Date().toISOString() });
});

// 서버 정보 엔드포인트
app.get('/.well-known/mcp-server-info', (req, res) => {
  res.json({
    name: "Multimodal Claude MCP Server",
    version: "1.0.0",
    description: "이미지, 음성, 문서를 통합적으로 처리하는 Claude MCP 서버",
    capabilities: [
      "image_processing",
      "speech_recognition",
      "document_analysis",
      "text_to_speech",
      "file_operations",
      "web_search"
    ],
    endpoints: {
      // 기본 엔드포인트
      "file/info": "파일 정보 조회",
      "file/read": "파일 읽기",
      "file/write": "파일 쓰기",
      "file/list": "디렉토리 목록 조회",
      "search/web": "웹 검색 수행",

      // 멀티모달 엔드포인트
      "multimodal/process": "단일 파일 처리",
      "multimodal/conversation": "멀티파트 대화 처리",
      "multimodal/tts": "텍스트를 음성으로 변환",
      "multimodal/summarize": "멀티모달 데이터 요약"
    }
  });
});

// 멀티모달 파일 처리 엔드포인트
app.post('/multimodal/process', authenticateRequest, multimodalHandler.singleUpload, multimodalHandler.processMultimodalFile);

// 멀티파트 대화 처리 엔드포인트
app.post('/multimodal/conversation', authenticateRequest, multimodalHandler.multiUpload, multimodalHandler.processMultipart);

// TTS 엔드포인트
app.post('/multimodal/tts', authenticateRequest, async (req, res) => {
  try {
    const { text, options } = req.body;

    if (!text) {
      return res.status(400).json({ error: '변환할 텍스트가 필요합니다.' });
    }

    const speechProcessor = require('./services/speechProcessor');
    const result = await speechProcessor.textToSpeech(text, options);

    // 오디오 파일 스트리밍
    res.setHeader('Content-Type', result.mimeType);
    fs.createReadStream(result.audioFile).pipe(res);

  } catch (error) {
    logger.error('TTS 처리 실패', { error: error.message });
    return res.status(500).json({ error: `TTS 처리 중 오류가 발생했습니다: ${error.message}` });
  }
});

// 멀티모달 데이터 요약 엔드포인트
app.post('/multimodal/summarize', authenticateRequest, multimodalHandler.multiUpload, async (req, res) => {
  try {
    // 요약할 텍스트 및 파일 처리
    const { text, options } = req.body;
    const fileResults = [];

    // 업로드된 파일 처리
    if (req.files && req.files.length > 0) {
      for (const file of req.files) {
        const result = await multimodalHandler.processFile(file.path, file.mimetype);
        fileResults.push({
          originalName: file.originalname,
          mimeType: file.mimetype,
          result
        });
      }
    }

    // Claude API를 사용한 요약 생성
    // (실제 구현은 Claude API 연동 방식에 따라 달라짐)

    return res.json({
      success: true,
      summary: "멀티모달 데이터 요약 결과가 여기에 표시됩니다.",
      fileInfo: fileResults.map(fr => ({
        name: fr.originalName,
        type: fr.mimeType
      }))
    });

  } catch (error) {
    logger.error('멀티모달 요약 실패', { error: error.message });
    return res.status(500).json({ error: `요약 중 오류가 발생했습니다: ${error.message}` });
  }
});

// 오류 처리 미들웨어
app.use((err, req, res, next) => {
  logger.error('서버 오류', { error: err.message, stack: err.stack });
  res.status(500).json({ error: '서버 내부 오류가 발생했습니다.' });
});

// 서버 시작
app.listen(PORT, () => {
  logger.info(`멀티모달 MCP 서버가 포트 ${PORT}에서 실행 중입니다.`);
  console.log(`멀티모달 MCP 서버가 포트 ${PORT}에서 실행 중입니다.`);
});

이제 멀티모달 MCP 서버의 기본 구조가 완성되었습니다. 이 서버는 이미지, 음성, 문서를 처리할 수 있는 다양한 엔드포인트를 제공하며, Claude와 통합하여 멀티모달 AI 비서를 구현할 수 있습니다.

Claude와의 통합: 사용자 인터페이스 구현

멀티모달 MCP 서버를 구축했으니, 이제 사용자가 이를 쉽게 활용할 수 있는 인터페이스를 만들어 보겠습니다. 웹 애플리케이션을 통해 Claude와 다양한 형태의 데이터를 주고받을 수 있는 인터페이스를 구현해 보겠습니다.

실제 업무 활용 사례

이제 구축한 멀티모달 MCP 서버와 Claude를 활용한 실제 업무 활용 사례를 살펴보겠습니다.

1. 회의 요약 및 액션 아이템 추출

팀 회의 녹음 파일과 회의 자료를 Claude에 전달하여 회의 내용을 요약하고 중요한 결정 사항과 액션 아이템을 추출할 수 있습니다.

// 회의 요약 요청 예시
const meetingSummaryRequest = {
  audioFile: "회의_녹음.mp3",
  documents: ["회의_자료.pdf", "이전_회의록.docx"],
  prompt: "회의 내용을 요약하고, 주요 결정 사항과 담당자별 액션 아이템을 추출해 주세요."
};

// API 호출 예시
const response = await fetch('http://localhost:3000/multimodal/conversation', {
  method: 'POST',
  headers: {
    'x-api-key': API_KEY,
    'Content-Type': 'multipart/form-data'
  },
  body: formData // audioFile, documents, prompt를 포함한 FormData 객체
});

const result = await response.json();

Claude의 응답 예시:

# 회의 요약

## 주요 내용
- 신규 제품 출시 일정 논의 (9월 15일로 확정)
- 마케팅 예산 15% 증액 승인
- 사용자 피드백 기반 UI 개선 필요성 논의

## 주요 결정 사항
1. 제품 출시일: 9월 15일
2. 베타 테스트 기간: 8월 1일 ~ 8월 31일
3. 마케팅 예산: 기존 대비 15% 증액
4. 주요 타겟 시장: 북미, 유럽, 동아시아

## 담당자별 액션 아이템
- 김부장: 제품 출시 로드맵 최종 확정 (7/25까지)
- 이과장: 베타 테스트 참여자 모집 계획 수립 (7/20까지)
- 박대리: UI 개선 사항 정리 및 우선순위 설정 (7/22까지)
- 정대리: 증액된 마케팅 예산 활용 계획 제출 (7/30까지)
- 전원: 다음 회의 전까지 경쟁사 제품 분석 자료 검토

## 다음 회의 일정
- 7월 31일 오후 2시, 같은 장소

2. 재무 보고서 분석 및 인사이트 생성

Excel 파일이나 PDF 형태의 재무 보고서를 Claude에 전달하여 주요 지표 분석, 트렌드 파악, 인사이트 생성을 자동화할 수 있습니다.

// 재무 보고서 분석 요청 예시
const financialAnalysisRequest = {
  documents: ["Q2_financial_report.xlsx", "previous_quarters.pdf"],
  prompt: "2분기 재무 보고서의 주요 지표를 분석하고, 전년 동기 및 직전 분기와 비교하여 트렌드를 파악해 주세요. 특히 수익성 지표와 현금 흐름에 주목해 주세요."
};

// API 호출 예시 (위와 유사)

Claude의 응답 예시:

# 2분기 재무 보고서 분석

## 주요 재무 지표 요약
| 지표 | Q2 2024 | Q1 2024 | Q2 2023 | Q1 대비 | 전년 동기 대비 |
|------|---------|---------|---------|---------|----------------|
| 매출 | $24.5M | $22.8M | $20.1M | +7.5% | +21.9% |
| 영업이익 | $5.2M | $4.7M | $4.1M | +10.6% | +26.8% |
| 영업이익률 | 21.2% | 20.6% | 20.4% | +0.6%p | +0.8%p |
| 순이익 | $4.1M | $3.8M | $3.2M | +7.9% | +28.1% |
| 현금 보유액 | $18.7M | $16.5M | $14.2M | +13.3% | +31.7% |
| 부채비율 | 32.5% | 35.2% | 38.7% | -2.7%p | -6.2%p |

## 핵심 인사이트
1. **매출 성장 가속화**: 전분기 대비 7.5%, 전년 동기 대비 21.9% 증가하며 성장세 가속화
2. **수익성 개선**: 영업이익률이 지속적으로 상승 중으로, 원가 절감 및 운영 효율화 노력이 성과를 보이고 있음
3. **현금 흐름 개선**: 현금 보유액이 $18.7M으로 증가하여 유동성이 크게 개선됨
4. **재무 건전성 강화**: 부채비율이 32.5%로 지속적으로 감소하여 재무 안정성 향상

## 주목할 부분
1. **제품별 수익성**: 신규 출시 제품군(B시리즈)의 영업이익률(28.3%)이 전체 평균보다 높음
2. **지역별 성과**: 동아시아 지역 매출이 전년 동기 대비 35.2% 증가하여 가장 높은 성장률 기록
3. **비용 구조**: 연구개발 투자가 매출 대비 15.2%로 증가 추세

## 권장 사항
1. 높은 성장을 보이는 B시리즈 제품군 마케팅 강화 고려
2. 동아시아 지역 영업 인력 확충 검토
3. 현금 보유액 증가에 따른 전략적 투자 기회 모색
4. 지속적인 비용 효율화로 영업이익률 개선 추세 유지

3. 제품 디자인 리뷰 및 피드백

제품 디자인 이미지와 기능 명세서를 Claude에 전달하여 디자인 리뷰와 개선 제안을 받을 수 있습니다.

// 제품 디자인 리뷰 요청 예시
const designReviewRequest = {
  images: ["product_design_front.jpg", "product_design_side.jpg", "UI_mockup.png"],
  documents: ["feature_specifications.docx"],
  prompt: "이 제품 디자인에 대한 사용자 경험 관점에서 리뷰해 주세요. 특히 직관성, 접근성, 심미성을 고려하여 피드백과 개선 제안을 제공해 주세요."
};

// API 호출 예시 (위와 유사)

Claude의 응답 예시:

# 제품 디자인 리뷰: 사용자 경험 관점

## 종합 평가

제공된 제품 디자인은 현대적이고 미니멀한 접근 방식을 취하고 있으며, 전반적으로 잘 구성되어 있습니다. 하지만 사용자 경험 관점에서 몇 가지 개선 사항이 확인됩니다.

## 강점

1.  **일관된 디자인 언어**: 제품 전체에 걸쳐 일관된 시각적 요소와 디자인 언어 사용
2.  **색상 대비**: 주요 기능 버튼의 색상 대비가 뛰어나 시인성이 좋음
3.  **깔끔한 레이아웃**: 불필요한 시각적 요소 없이 깔끔하게 정리된 레이아웃

## 개선 필요 사항

### 1\. 직관성

-   **메뉴 구조**: 주요 기능에 도달하기 위한 단계가 많음 (현재 3단계 → 2단계로 축소 권장)
-   **아이콘 명확성**: 설정과 공유 아이콘이 유사하여 혼동 가능성 있음
-   **피드백 부족**: 사용자 액션 후 시스템 피드백이 미미함

### 2\. 접근성

-   **터치 타겟 크기**: 여러 버튼의 크기가 표준(최소 44x44px) 미달
-   **색상 접근성**: 일부 텍스트와 배경 간 대비가 WCAG 기준(4.5:1) 미달
-   **대체 텍스트**: 이미지에 대한 대체 텍스트 미제공

### 3\. 심미성

-   **일관성 있는 여백**: 좌우 여백이 일부 화면에서 불균형함
-   **타이포그래피 계층**: 정보 계층 구조를 더 명확히 나타낼 필요 있음

## 개선 제안

1.  주요 기능에 대한 직접 접근 경로 추가 (원터치 접근)
2.  설정과 공유 아이콘 디자인 차별화
3.  모든 버튼 크기 최소 44x44px로 확대
4.  저대비 텍스트-배경 조합 수정 (특히 연한 회색 텍스트)
5.  모든 주요 기능에 햅틱 피드백 추가
6.  일관된 여백 체계 적용 (8의 배수 그리드 시스템 권장)

## 개선 가이드라인 요약
아래 가이드라인을 따라 다음 반복 디자인에 적용하기를 권장합니다:

1. 버튼 크기 최소 44×44px 확보
2. 모든 텍스트-배경 색상 조합의 대비율 4.5:1 이상 유지
3. 8px 단위 그리드 시스템 일관되게 적용
4. 모든 이미지 및 기능 버튼에 대체 텍스트 추가
5. 주요 작업별 햅틱 피드백 패턴 정의 및 일관되게 적용

이 개선사항들을 적용하면 사용자 경험이 크게 향상되고, 더 넓은 사용자층에게 접근 가능한 제품이 될 것입니다.

멀티모달 MCP 설계 시 고려사항

멀티모달 MCP 서버를 구축할 때 고려해야 할 몇 가지 중요한 사항이 있습니다.

1. 확장성 및 성능

멀티모달 데이터 처리는 텍스트만 처리하는 것보다 계산 부하가 훨씬 큽니다. 이미지, 음성, 문서 처리는 많은 컴퓨팅 리소스를 필요로 하므로 시스템 확장성을 염두에 두어야 합니다.

• 비동기 처리: 대용량 파일 처리는 비동기적으로 수행하고, 작업 큐 시스템을 활용하세요.
• 분산 처리: 대규모 배포의 경우 마이크로서비스 아키텍처를 고려하여 각 모달리티별로 전용 서비스를 구성하세요.
• 캐싱: 자주 사용되는 파일 분석 결과를 캐싱하여 중복된 처리를 방지하세요.
• 리소스 관리: 메모리 및 CPU 사용량을 모니터링하고 필요에 따라 자동으로 스케일링할 수 있는 시스템을 구축하세요.

2. 보안 및 개인정보 보호

멀티모달 데이터는 종종 민감한 정보를 포함하고 있을 수 있습니다. 이를 처리할 때는 보안과 개인정보 보호에 특별한 주의가 필요합니다.

• 데이터 암호화: 저장 데이터와 전송 중인 데이터 모두 암호화하세요.
• 임시 파일 관리: 분석이 완료된 후에는 임시 파일을 안전하게 삭제하세요.
• 액세스 제어: 역할 기반 액세스 제어(RBAC)를 구현하여 권한이 있는 사용자만 특정 유형의 데이터에 접근할 수 있도록 하세요.
• 개인정보 탐지 및 마스킹: 이미지나 문서에서 개인 식별 정보(PII)를 자동으로 탐지하고 마스킹하는 기능을 구현하세요.
• 감사 로깅: 모든 데이터 액세스와 처리를 기록하여 추적 가능성을 보장하세요.

3. 사용자 경험

멀티모달 인터페이스는 직관적이고 사용하기 쉬워야 합니다.

• 다양한 입력 방식: 텍스트, 음성, 파일 업로드 등 다양한 방식으로 상호작용할 수 있도록 제공하세요.
• 피드백 제공: 파일 처리 중 진행 상황을 사용자에게 실시간으로 알려주세요.
• 접근성: 다양한 장애를 가진 사용자도 시스템을 이용할 수 있도록 접근성 지침을 준수하세요.
• 적응형 인터페이스: 사용자 환경(데스크톱, 모바일 등)에 따라 최적화된 인터페이스를 제공하세요.
• 컨텍스트 유지: 멀티모달 대화에서 이전 컨텍스트를 유지하여 자연스러운 대화 흐름을 보장하세요.

미래 발전 방향

멀티모달 Claude 시스템은 다음과 같은 방향으로 더욱 발전할 수 있습니다:

1. 고급 분석 기능: 이미지 생성, 3D 모델 해석, 비디오 분석 등 더 복잡한 멀티모달 분석 기능 추가
2. 맞춤형 도메인 적응: 특정 업종(의료, 법률, 금융 등)에 특화된 멀티모달 모델 개발
3. 실시간 협업: 여러 사용자가 동시에 참여하는 실시간 멀티모달 협업 환경 구축
4. IoT 통합: 스마트 홈, 산업 자동화 등 IoT 환경과의 통합
5. 증강현실/가상현실 통합: AR/VR 환경에서 Claude를 활용한 몰입형 경험 제공
6. 자율적 에이전트 개발: 특정 목표를 달성하기 위해 자율적으로 행동하는 멀티모달 에이전트 구현

결론

이번 포스팅에서는 Claude AI를 멀티모달 지능형 비서로 확장하기 위한 MCP 서버 구현 방법을 살펴보았습니다. 이미지 처리, 음성 인식 및 합성, 문서 분석과 같은 다양한 기능을 통합하여 보다 자연스럽고 인간과 유사한 방식으로 상호작용할 수 있는 AI 시스템을 구축할 수 있습니다.

멀티모달 Claude는 회의 요약, 재무 보고서 분석, 제품 디자인 리뷰 등 다양한 비즈니스 상황에서 강력한 지원 도구로 활용될 수 있습니다. 직관적인 인터페이스와 강력한 분석 기능을 결합하여 업무 효율성을 크게 향상시킬 수 있습니다.

이러한 시스템을 구축할 때는 확장성, 보안, 사용자 경험을 핵심 고려 사항으로 염두에 두어야 합니다. 또한 관련 기술의 빠른 발전에 맞춰 지속적으로 기능을 개선하고 확장해 나가는 노력이 필요합니다.

멀티모달 AI의 시대가 도래하고 있습니다. Claude와 MCP를 활용하여 이 새로운 시대의 최전선에 서 보세요!