IBM Bob과 MCP 통합

{
  "name": "arxiv-server",
  "version": "0.1.0",
  "description": "MCP server for read-only access to arXiv papers",
  "type": "module",
  "bin": {
    "arxiv-server": "./build/index.js"
  },
  "files": [
    "build"
  ],
  "scripts": {
    "build": "tsc && node -e \"require('fs').chmodSync('build/index.js', '755')\"",
    "prepare": "npm run build",
    "watch": "tsc --watch"
  },
  "keywords": [
    "mcp",
    "arxiv",
    "research",
    "papers"
  ],
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.0.4",
    "axios": "^1.7.9",
    "zod": "^3.24.1"
  },
  "devDependencies": {
    "@types/node": "^22.10.5",
    "typescript": "^5.7.3"
  }
}

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "Node16",
    "moduleResolution": "Node16",
    "outDir": "./build",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "resolveJsonModule": true,
    "declaration": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "build"]
}

#!/usr/bin/env node
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import axios from 'axios';

// Define types for arXiv API responses
interface ArxivEntry {
  id: string;
  title: string;
  summary: string;
  authors: Array<{ name: string }>;
  published: string;
  updated: string;
  categories: string[];
  primary_category: string;
  links: Array<{ href: string; rel: string; type?: string }>;
}

interface ArxivSearchResult {
  entries: ArxivEntry[];
  totalResults: number;
  startIndex: number;
  itemsPerPage: number;
}

// Create an MCP server
const server = new McpServer({
  name: "arxiv-server",
  version: "0.1.0"
});

// Create axios instance for arXiv API
const arxivApi = axios.create({
  baseURL: 'http://export.arxiv.org/api',
  timeout: 30000,
});

/**
 * Parse arXiv API XML response to JSON
 */
function parseArxivXML(xmlData: string): ArxivSearchResult {
  const entries: ArxivEntry[] = [];
  
  // Extract total results
  const totalResultsMatch = xmlData.match(/<opensearch:totalResults[^>]*>(\d+)<\/opensearch:totalResults>/);
  const totalResults = totalResultsMatch ? parseInt(totalResultsMatch[1]) : 0;
  
  const startIndexMatch = xmlData.match(/<opensearch:startIndex[^>]*>(\d+)<\/opensearch:startIndex>/);
  const startIndex = startIndexMatch ? parseInt(startIndexMatch[1]) : 0;
  
  const itemsPerPageMatch = xmlData.match(/<opensearch:itemsPerPage[^>]*>(\d+)<\/opensearch:itemsPerPage>/);
  const itemsPerPage = itemsPerPageMatch ? parseInt(itemsPerPageMatch[1]) : 0;
  
  // Extract entries
  const entryRegex = /<entry>([\s\S]*?)<\/entry>/g;
  let entryMatch;
  
  while ((entryMatch = entryRegex.exec(xmlData)) !== null) {
    const entryXml = entryMatch[1];
    
    // Extract ID
    const idMatch = entryXml.match(/<id>([^<]+)<\/id>/);
    const id = idMatch ? idMatch[1] : '';
    
    // Extract title
    const titleMatch = entryXml.match(/<title>([^<]+)<\/title>/);
    const title = titleMatch ? titleMatch[1].trim().replace(/\s+/g, ' ') : '';
    
    // Extract summary
    const summaryMatch = entryXml.match(/<summary>([^<]+)<\/summary>/);
    const summary = summaryMatch ? summaryMatch[1].trim().replace(/\s+/g, ' ') : '';
    
    // Extract authors
    const authors: Array<{ name: string }> = [];
    const authorRegex = /<author>\s*<name>([^<]+)<\/name>/g;
    let authorMatch;
    while ((authorMatch = authorRegex.exec(entryXml)) !== null) {
      authors.push({ name: authorMatch[1].trim() });
    }
    
    // Extract published date
    const publishedMatch = entryXml.match(/<published>([^<]+)<\/published>/);
    const published = publishedMatch ? publishedMatch[1] : '';
    
    // Extract updated date
    const updatedMatch = entryXml.match(/<updated>([^<]+)<\/updated>/);
    const updated = updatedMatch ? updatedMatch[1] : '';
    
    // Extract categories
    const categories: string[] = [];
    const categoryRegex = /<category[^>]+term="([^"]+)"/g;
    let categoryMatch;
    while ((categoryMatch = categoryRegex.exec(entryXml)) !== null) {
      categories.push(categoryMatch[1]);
    }
    
    const primary_category = categories[0] || '';
    
    // Extract links
    const links: Array<{ href: string; rel: string; type?: string }> = [];
    const linkRegex = /<link[^>]+href="([^"]+)"[^>]+rel="([^"]+)"(?:[^>]+type="([^"]+)")?/g;
    let linkMatch;
    while ((linkMatch = linkRegex.exec(entryXml)) !== null) {
      links.push({
        href: linkMatch[1],
        rel: linkMatch[2],
        type: linkMatch[3]
      });
    }
    
    entries.push({
      id,
      title,
      summary,
      authors,
      published,
      updated,
      categories,
      primary_category,
      links
    });
  }
  
  return {
    entries,
    totalResults,
    startIndex,
    itemsPerPage
  };
}

/**
 * Format search results for display
 */
function formatSearchResults(result: ArxivSearchResult): string {
  let output = `Found ${result.totalResults} results (showing ${result.entries.length})\n\n`;
  
  result.entries.forEach((entry, index) => {
    output += `${index + 1}. ${entry.title}\n`;
    output += `   ID: ${entry.id}\n`;
    output += `   Authors: ${entry.authors.map(a => a.name).join(', ')}\n`;
    output += `   Published: ${entry.published}\n`;
    output += `   Categories: ${entry.categories.join(', ')}\n`;
    output += `   Abstract: ${entry.summary.substring(0, 300)}${entry.summary.length > 300 ? '...' : ''}\n`;
    
    // Find abstract link (not PDF)
    const abstractLink = entry.links.find(l => l.rel === 'alternate');
    if (abstractLink) {
      output += `   URL: ${abstractLink.href}\n`;
    }
    output += '\n';
  });
  
  return output;
}

// Add a tool for searching arXiv papers
server.tool(
  "search_arxiv",
  {
    query: z.string().describe("Search query (supports arXiv query syntax)"),
    max_results: z.number().min(1).max(50).optional().describe("Maximum number of results to return (1-50, default: 10)"),
    start: z.number().min(0).optional().describe("Starting index for pagination (default: 0)"),
    sort_by: z.enum(["relevance", "lastUpdatedDate", "submittedDate"]).optional().describe("Sort order (default: relevance)"),
    sort_order: z.enum(["ascending", "descending"]).optional().describe("Sort direction (default: descending)")
  },
  async ({ query, max_results = 10, start = 0, sort_by = "relevance", sort_order = "descending" }) => {
    try {
      // Enforce reasonable limits
      const limitedMaxResults = Math.min(max_results, 50);
      const limitedStart = Math.max(start, 0);
      
      // Build query parameters
      const params: Record<string, string | number> = {
        search_query: query,
        start: limitedStart,
        max_results: limitedMaxResults,
      };
      
      if (sort_by) {
        params.sortBy = sort_by;
      }
      
      if (sort_order) {
        params.sortOrder = sort_order;
      }
      
      const response = await arxivApi.get('/query', { params });
      
      // Parse XML response
      const result = parseArxivXML(response.data);
      
      // Format results
      const formattedResults = formatSearchResults(result);
      
      return {
        content: [
          {
            type: "text",
            text: formattedResults,
          },
        ],
      };
    } catch (error) {
      if (axios.isAxiosError(error)) {
        return {
          content: [
            {
              type: "text",
              text: `arXiv API error: ${error.response?.data?.message ?? error.message}`,
            },
          ],
          isError: true,
        };
      }
      throw error;
    }
  }
);

// Start receiving messages on stdin and sending messages on stdout
const transport = new StdioServerTransport();
await server.connect(transport);
console.error('arXiv MCP server running on stdio');

// Bob으로 생성됨

{ 
	"mcpServers": {}
	"mcpServers": { 
		"arxiv": { 
			"command": "node", 
			"args": [ "/here/is/the/path/to/arxiv-server/build/index.js" 
				], 
			"disabled": false, 
			"alwaysAllow": [], 
			"disabledTools": [] 
		} 
	}
}

kind: mcp
name: arxiv-toolkit
description: Toolkit for searching arXiv research papers. arXiv 데이터베이스의 논문 메타데이터, 초록 및 출판 정보에 액세스할 수 있도록 합니다.package_root: /local/path/to/arxiv-serverlanguage: nodecommand: node /local/path/to/arxiv-server/arxiv-server/build/index.jstools:- "*"# Bob으로 생성

name: research-assistant
kind: native
description: arXiv에서 학술 논문을 찾고 요약하는 데 도움을 주는 AI 연구 도우미입니다. 학술 문헌 검색, 연구 결과 설명 및 인용 정보 제공에 특화되어 있습니다.
title: 연구 도우미
instructions: |
당신은 arXiv의 학술 문헌 검색을 전문으로 하는 연구 도우미입니다.
## 주요 기능
- 모든 과학 분야의 주제에 대해 arXiv 논문을 검색합니다.
- 초록을 바탕으로 연구 결과를 이해하기 쉬운 언어로 요약합니다.
- 주요 저자와 연구 동향을 파악합니다.
- 관련 논문과 연구 주제를 제안합니다.
- arXiv ID와 URL을 포함한 올바른 인용 정보를 제공합니다.
## 사용자에게 응답할 때
1. 항상 arXiv ID와 논문의 직접 URL을 제공합니다.
2. 초록을 이해하기 쉬운 언어로 요약합니다.
3. 주요 기여와 연구 성과를 강조합니다.
4. 관련이 있는 경우 후속 검색을 제안합니다.
5. 간결하면서도 충분한 정보를 제공합니다.
## search_arxiv 툴 사용
사용 가능한 매개변수:
- query (필수): arXiv 검색 구문을 사용하는 검색어
- max_results (선택 사항): 검색할 논문 수(1~50, 기본값: 10)
- start (선택 사항): 페이지 매김을 위한 시작 인덱스(기본값: 0)
- sort_by (선택 사항): "relevance", "submittedDate" 또는 "lastUpdatedDate"
- sort_order (선택 사항): "ascending" 또는 "descending"
## 고급 검색 구문
검색어에서 다음 연산자를 사용할 수 있습니다.
- ti:keyword 
- 제목에서 검색
- au:author 
- 저자 이름으로 검색- abs:keyword 
- 초록에서 검색
- cat:category 
- 카테고리로 필터링(예: cs.AI, quant-ph, math.CO)
- AND, OR, ANDNOT 
- 불리언 연산자
예시:
- "ti:transformer AND cat:cs.LG" 
- 머신 러닝 분야의 Transformer 논문
- "au:Hinton" - Geoffrey Hinton의 논문
- "quantum computing AND cat:quant-ph" 
- 양자물리학 분야의 양자 컴퓨팅 논문
## 주요 카테고리
- cs.AI 
- 인공지능
- cs.LG - 머신 러닝
- cs.CL - 자연어 처리
- cs.CV - 컴퓨터 비전
- quant-ph - 양자물리학
- math.CO - 조합론
- stat.ML - 머신 러닝(통계)
## 응답 형식논문를 소개할 때는 다음 형식을 사용합니다.
**"논문 제목"**
- 저자: [저자 이름]
- 출판일: [날짜]
- 카테고리: [카테고리]
- 요약: [초록의 간략한 요약]
- [논문 보기](arXiv URL)## 예외 상황 처리
- 검색 결과가 없는 경우: 대체 검색어나 더 포괄적인 검색어를 제안합니다.
- 검색 결과가 너무 많은 경우: 카테고리나 날짜 필터를 사용하여 검색 범위를 좁히도록 권장합니다.
- 사용자가 PDF를 요청하는 경우: 메타데이터만 제공할 수 있음을 설명하고, 논문에 접근할 수 있는 URL을 함께 제공합니다.
- 검색어가 불명확한 경우: 연구 분야나 구체적인 관심사에 대해 확인 질문을 합니다.

tools:
- search_arxivconfig:hidden: falseenable_cot: true

tags:
- research
- academic
- papers
- arxiv
- literature
-search

# Bob으로 생성됨