MCP零基础学习（7）｜实战指南：构建论文分析智能体

mkdir paper-analysis-agent
cd paper-analysis-agent
npm init -y

npm install @modelcontextprotocol/server-nodejs pdf-parse

const { Server } = require('@modelcontextprotocol/server-nodejs');
const { analyzePaper, extractPaperInfo } = require('./paperAnalyzer');

class PaperAnalysisServer {
constructor() {
    this.server = new Server(
      {
        name: 'paper-analysis-server',
        version: '1.0.0',
      },
      {
        capabilities: {
          resources: {},
          tools: {},
        },
      }
    );

    this.setupResources();
    this.setupTools();
    this.setupErrorHandling();
  }

  setupResources() {
    // 资源相关设置将在后续实现
  }

  setupTools() {
    this.server.setRequestHandler('tools/call', async (request) => {
      const { name, arguments: args } = request.params;

      try {
        switch (name) {
          case'analyze_paper':
            returnawaitthis.analyzePaper(args);
          case'extract_paper_info':
            returnawaitthis.extractPaperInfo(args);
          case'summarize_paper':
            returnawaitthis.summarizePaper(args);
          default:
            thrownewError(`Unknown tool: ${name}`);
        }
      } catch (error) {
        return {
          content: [
            {
              type: 'text',
              text: `Error: ${error.message}`,
            },
          ],
          isError: true,
        };
      }
    });
  }

  setupErrorHandling() {
    this.server.onerror = (error) => {
      console.error('Server error:', error);
    };
  }

async analyzePaper(args) {
    const { pdfPath, question } = args;
    
    if (!pdfPath) {
      thrownewError('PDF path is required');
    }

    const analysis = await analyzePaper(pdfPath, question);
    
    return {
      content: [
        {
          type: 'text',
          text: analysis,
        },
      ],
    };
  }

async extractPaperInfo(args) {
    const { pdfPath } = args;
    
    if (!pdfPath) {
      thrownewError('PDF path is required');
    }

    const info = await extractPaperInfo(pdfPath);
    
    return {
      content: [
        {
          type: 'text',
          text: JSON.stringify(info, null, 2),
        },
      ],
    };
  }

async summarizePaper(args) {
    const { pdfPath } = args;
    
    if (!pdfPath) {
      thrownewError('PDF path is required');
    }

    // 这里实现论文总结逻辑
    const summary = "论文总结内容将在这里显示";
    
    return {
      content: [
        {
          type: 'text',
          text: summary,
        },
      ],
    };
  }

async run() {
    awaitthis.server.connect();
    console.log('Paper Analysis MCP Server is running...');
  }
}

const server = new PaperAnalysisServer();
server.run().catch(console.error);

const fs = require('fs');
const pdf = require('pdf-parse');

class PaperAnalyzer {
constructor() {
    this.cache = newMap();
  }

async parsePDF(pdfPath) {
    if (this.cache.has(pdfPath)) {
      returnthis.cache.get(pdfPath);
    }

    try {
      const dataBuffer = fs.readFileSync(pdfPath);
      const data = await pdf(dataBuffer);
      
      const result = {
        text: data.text,
        info: data.info,
        metadata: data.metadata,
      };

      this.cache.set(pdfPath, result);
      return result;
    } catch (error) {
      thrownewError(`Failed to parse PDF: ${error.message}`);
    }
  }

async extractPaperInfo(pdfPath) {
    const paperData = awaitthis.parsePDF(pdfPath);
    const text = paperData.text;

    // 简单的信息提取逻辑（实际应用中可能需要更复杂的 NLP 处理）
    const titleMatch = text.match(/^(.+)\n\n(?:Abstract|ABSTRACT)/m);
    const abstractMatch = text.match(/(?:Abstract|ABSTRACT)[\s\S]*?(\n\n|$)/i);
    const authorMatch = text.match(/(?:Authors?|By)[:\s]+(.+?)(?=\n\n)/i);

    return {
      title: titleMatch ? titleMatch[1].trim() : 'Unknown',
      authors: authorMatch ? authorMatch[1].trim() : 'Unknown',
      abstract: abstractMatch ? abstractMatch[0].replace(/(Abstract|ABSTRACT)/i, '').trim() : 'Unknown',
      pageCount: paperData.info.Pages || 'Unknown',
    };
  }

async analyzeContent(pdfPath, question) {
    const paperData = awaitthis.parsePDF(pdfPath);
    
    // 这里可以实现更复杂的内容分析逻辑
    // 目前只是简单返回包含问题的响应
    return`关于论文的分析结果：
问题: ${question}
回答: 根据论文内容，这里应该包含针对问题的详细分析。`;
  }
}

// 创建单例实例
const analyzer = new PaperAnalyzer();

// 导出函数
asyncfunction analyzePaper(pdfPath, question) {
returnawait analyzer.analyzeContent(pdfPath, question);
}

asyncfunction extractPaperInfo(pdfPath) {
returnawait analyzer.extractPaperInfo(pdfPath);
}

module.exports = {
  analyzePaper,
  extractPaperInfo,
};

{
  "mcpServers": {
    "paper-analysis": {
      "command": "node",
      "args": ["/path/to/your/paper-analysis-agent/server.js"],
      "env": {}
    }
  }
}

const { analyzePaper, extractPaperInfo } = require('./paperAnalyzer');

asyncfunction test() {
try {
    // 测试信息提取
    const info = await extractPaperInfo('./sample.pdf');
    console.log('论文信息:', info);

    // 测试内容分析
    const analysis = await analyzePaper(
      './sample.pdf',
      '这篇论文的主要贡献是什么？'
    );
    console.log('分析结果:', analysis);
  } catch (error) {
    console.error('测试失败:', error);
  }
}

test();

node server.js

用户: 请分析这篇论文 "/path/to/paper.pdf"，并告诉我它的主要研究方法。

Claude: 我将使用论文分析工具来帮您解答这个问题。

[调用 analyze_paper 工具]