MCP Server Integration

// server.js - Main MCP server
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import PDFHunter from './pdf-hunter.js';
import DownloadManager from './download-manager.js';
import ExtractionPipeline from './extraction-pipeline.js';
import PaperOrganizer from './organizer.js';

class PDFResearchServer {
  constructor() {
    this.server = new Server(
      {
        name: 'pdf-research-assistant',
        version: '1.0.0',
      },
      {
        capabilities: {
          tools: {},
        },
      }
    );

    this.setupHandlers();
  }

  setupHandlers() {
    // List available tools
    this.server.setRequestHandler('tools/list', async () => ({
      tools: [
        {
          name: 'search_papers',
          description: 'Search multiple academic databases for papers',
          inputSchema: {
            type: 'object',
            properties: {
              query: { type: 'string', description: 'Search query' },
              databases: {
                type: 'array',
                items: { enum: ['pubmed', 'arxiv', 'jstor', 'ieee'] },
                description: 'Databases to search'
              },
              maxResults: { type: 'number', default: 50 },
              yearFrom: { type: 'number', description: 'Filter from year' }
            },
            required: ['query', 'databases']
          }
        },
        {
          name: 'download_papers',
          description: 'Download PDFs for discovered papers',
          inputSchema: {
            type: 'object',
            properties: {
              papers: { type: 'array', description: 'Papers to download' },
              downloadDir: { type: 'string', default: './papers' },
              concurrency: { type: 'number', default: 5 }
            },
            required: ['papers']
          }
        },
        {
          name: 'extract_content',
          description: 'Extract text and citations from PDFs',
          inputSchema: {
            type: 'object',
            properties: {
              pdfPaths: { type: 'array', description: 'Paths to PDFs' },
              useOCR: { type: 'boolean', default: false },
              extractCitations: { type: 'boolean', default: true }
            },
            required: ['pdfPaths']
          }
        },
        {
          name: 'organize_papers',
          description: 'Organize papers into directory structure',
          inputSchema: {
            type: 'object',
            properties: {
              papers: { type: 'array' },
              strategy: {
                type: 'string',
                enum: ['topic', 'date', 'topic-date', 'author'],
                default: 'topic-date'
              },
              baseDir: { type: 'string', default: './research' }
            },
            required: ['papers']
          }
        },
        {
          name: 'full_research_pipeline',
          description: 'Complete pipeline: search → download → extract → organize',
          inputSchema: {
            type: 'object',
            properties: {
              query: { type: 'string' },
              databases: { type: 'array' },
              maxResults: { type: 'number', default: 50 },
              yearFrom: { type: 'number' },
              downloadDir: { type: 'string', default: './papers' },
              organizeStrategy: { type: 'string', default: 'topic-date' },
              extractText: { type: 'boolean', default: true }
            },
            required: ['query', 'databases']
          }
        }
      ]
    }));

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

      try {
        let result;

        switch (name) {
          case 'search_papers':
            result = await this.handleSearchPapers(args);
            break;
          case 'download_papers':
            result = await this.handleDownloadPapers(args);
            break;
          case 'extract_content':
            result = await this.handleExtractContent(args);
            break;
          case 'organize_papers':
            result = await this.handleOrganizePapers(args);
            break;
          case 'full_research_pipeline':
            result = await this.handleFullPipeline(args);
            break;
          default:
            throw new Error(`Unknown tool: ${name}`);
        }

        return {
          content: [
            {
              type: 'text',
              text: JSON.stringify(result, null, 2)
            }
          ]
        };

      } catch (error) {
        return {
          content: [
            {
              type: 'text',
              text: `Error: ${error.message}`
            }
          ],
          isError: true
        };
      }
    });
  }

  async start() {
    const transport = new StdioServerTransport();
    await this.server.connect(transport);
    console.error('PDF Research Assistant MCP server running');
  }
}

// Start server
const server = new PDFResearchServer();
server.start().catch(console.error);

// pdf-hunter.js - Multi-database coordinator
import PubMedDiscovery from './discovery/pubmed-discovery.js';
import ArXivDiscovery from './discovery/arxiv-discovery.js';
import JSTORDiscovery from './discovery/jstor-discovery.js';
import IEEEDiscovery from './discovery/ieee-discovery.js';
import PaperDeduplicator from './deduplication.js';

class PDFHunter {
  constructor(options = {}) {
    this.authPaths = options.authPaths || {};
    this.deduplicator = new PaperDeduplicator();
  }

  /**
   * Search multiple databases and deduplicate results
   */
  async searchMultiple(query, databases, maxResults = 50, yearFrom = null) {
    const searchPromises = databases.map(db =>
      this.searchDatabase(db, query, maxResults, yearFrom)
    );

    const results = await Promise.allSettled(searchPromises);

    const allPapers = [];
    const byDatabase = {};

    for (let i = 0; i < results.length; i++) {
      const db = databases[i];
      const result = results[i];

      if (result.status === 'fulfilled') {
        const papers = result.value.papers.map(p => ({ ...p, source: db }));
        allPapers.push(...papers);
        byDatabase[db] = {
          count: papers.length,
          status: 'success'
        };
      } else {
        console.error(`${db} search failed:`, result.reason);
        byDatabase[db] = {
          count: 0,
          status: 'failed',
          error: result.reason.message
        };
      }
    }

    // Deduplicate across databases
    const uniquePapers = this.deduplicator.deduplicate(allPapers);

    return {
      papers: uniquePapers,
      totalBeforeDedup: allPapers.length,
      totalAfterDedup: uniquePapers.length,
      byDatabase
    };
  }

  async searchDatabase(database, query, maxResults, yearFrom) {
    switch (database) {
      case 'pubmed':
        return await this.searchPubMed(query, maxResults, yearFrom);
      case 'arxiv':
        return await this.searchArXiv(query, maxResults);
      case 'jstor':
        return await this.searchJSTOR(query, maxResults, yearFrom);
      case 'ieee':
        return await this.searchIEEE(query, maxResults);
      default:
        throw new Error(`Unknown database: ${database}`);
    }
  }

  async searchPubMed(query, maxResults, yearFrom) {
    const discovery = new PubMedDiscovery();
    return await discovery.search(query, maxResults, yearFrom);
  }

  async searchArXiv(query, maxResults) {
    const discovery = new ArXivDiscovery();
    return await discovery.search(query, maxResults);
  }

  async searchJSTOR(query, maxResults, yearFrom) {
    const discovery = new JSTORDiscovery(this.authPaths.jstor);
    return await discovery.search(query, maxResults, yearFrom);
  }

  async searchIEEE(query, maxResults) {
    const discovery = new IEEEDiscovery();
    return await discovery.search(query, maxResults);
  }
}

export default PDFHunter;

// Tool implementation methods (inside PDFResearchServer class)

async handleSearchPapers(args) {
  const hunter = new PDFHunter();
  const results = await hunter.searchMultiple(
    args.query,
    args.databases,
    args.maxResults,
    args.yearFrom
  );

  return {
    totalPapers: results.papers.length,
    papers: results.papers,
    byDatabase: results.byDatabase
  };
}

async handleDownloadPapers(args) {
  const manager = new DownloadManager({
    downloadDir: args.downloadDir,
    concurrency: args.concurrency
  });

  const results = await manager.downloadBatch(args.papers, (progress) => {
    console.log(`Progress: ${progress.paper.title} - ${progress.status}`);
  });

  return {
    stats: manager.getStats(),
    results: results.results
  };
}

async handleExtractContent(args) {
  const pipeline = new ExtractionPipeline({
    useOCR: args.useOCR,
    extractCitations: args.extractCitations
  });

  const extracted = [];

  for (const pdfPath of args.pdfPaths) {
    const data = await pipeline.extractFromPDF(pdfPath);
    extracted.push(data);
  }

  return {
    totalProcessed: extracted.length,
    extracted
  };
}

async handleOrganizePapers(args) {
  const organizer = new PaperOrganizer(args.baseDir);
  const organized = await organizer.organize(args.papers, args.strategy);

  return {
    strategy: args.strategy,
    categories: Object.keys(organized).length,
    organized
  };
}

async handleFullPipeline(args) {
  const results = {
    search: null,
    download: null,
    extraction: null,
    organization: null
  };

  // Step 1: Search
  console.log('Step 1: Searching databases...');
  const hunter = new PDFHunter();
  results.search = await hunter.searchMultiple(
    args.query,
    args.databases,
    args.maxResults,
    args.yearFrom
  );

  // Step 2: Download
  console.log(`Step 2: Downloading ${results.search.papers.length} papers...`);
  const manager = new DownloadManager({
    downloadDir: args.downloadDir,
    concurrency: 5
  });
  results.download = await manager.downloadBatch(results.search.papers);

  // Step 3: Extract (if requested)
  if (args.extractText) {
    console.log('Step 3: Extracting content...');
    const pipeline = new ExtractionPipeline({
      extractCitations: true
    });

    const downloaded = results.download.results
      .filter(r => r.status === 'fulfilled')
      .map(r => r.result.filepath);

    results.extraction = [];
    for (const filepath of downloaded) {
      const data = await pipeline.extractFromPDF(filepath);
      results.extraction.push(data);
    }
  }

  // Step 4: Organize
  console.log('Step 4: Organizing papers...');
  const organizer = new PaperOrganizer('./research');

  // Attach extracted data to papers
  const papersWithData = results.search.papers.map(paper => {
    const extracted = results.extraction?.find(e =>
      e.filepath.includes(paper.title.substring(0, 20))
    );
    return { ...paper, extracted };
  });

  results.organization = await organizer.organize(
    papersWithData,
    args.organizeStrategy
  );

  return {
    completed: true,
    summary: {
      papersFound: results.search.papers.length,
      papersDownloaded: results.download.stats.completed,
      papersExtracted: results.extraction?.length || 0,
      categories: Object.keys(results.organization).length
    },
    details: results
  };
}