Customization Patterns: Making It Yours

// scripts/cs-research-workflow.ts

async function csResearchWorkflow(topic: string) {
  // Step 1: Search arXiv
  const arxivPapers = await mcp.invoke('arxiv_search', {
    query: topic,
    category: 'cs.LG', // Machine Learning
    max_results: 100
  });

  // Step 2: For each paper, find associated GitHub repos
  const papersWithCode = await Promise.all(
    arxivPapers.map(async (paper) => {
      const github = await mcp.invoke('github_search', {
        query: `${paper.title} ${paper.authors[0]}`,
        language: 'python'
      });
      return { ...paper, github_repos: github.repos };
    })
  );

  // Step 3: Clone and analyze code quality
  for (const paper of papersWithCode) {
    if (paper.github_repos.length > 0) {
      const repo = paper.github_repos[0];
      await mcp.invoke('clone_repo', { url: repo.url });

      // Analyze code quality
      const analysis = await mcp.invoke('analyze_code', {
        repo_path: repo.local_path,
        metrics: ['test_coverage', 'documentation', 'activity']
      });

      paper.code_quality = analysis;
    }
  }

  // Step 4: Rank by paper quality + code availability
  const ranked = rankByQuality(papersWithCode, {
    weights: {
      citations: 0.3,
      code_availability: 0.3,
      code_quality: 0.2,
      recency: 0.2
    }
  });

  return ranked;
}

// scripts/humanities-research-workflow.ts

async function humanitiesResearchWorkflow(topic: string, era: string) {
  // Step 1: Search JSTOR for scholarly articles
  const jstorArticles = await mcp.invoke('jstor_search', {
    query: topic,
    date_range: era,
    disciplines: ['History', 'Literature', 'Philosophy']
  });

  // Step 2: Search Archive.org for primary sources
  const primarySources = await mcp.invoke('archive_org_search', {
    query: topic,
    mediatype: 'texts',
    year_range: era
  });

  // Step 3: Download and OCR primary sources
  for (const source of primarySources) {
    await mcp.invoke('download_archive_item', {
      identifier: source.identifier
    });

    // OCR if needed
    if (source.requires_ocr) {
      await mcp.invoke('ocr_document', {
        input: source.local_path,
        language: 'eng'
      });
    }
  }

  // Step 4: Cross-reference: which scholars cite which primary sources?
  const crossRef = await analyzeSourceCitations(jstorArticles, primarySources);

  // Step 5: Generate scholarly report
  const report = await mcp.invoke('ask-gemini', {
    prompt: `Analyze the relationship between these ${jstorArticles.length} scholarly articles
             and ${primarySources.length} primary sources on "${topic}" in the ${era} era.

             Cross-reference data: ${JSON.stringify(crossRef)}

             Identify:
             1. Most-cited primary sources
             2. Scholarly consensus and debates
             3. Under-utilized primary sources
             4. Historiographical trends`,
    model: 'gemini-2.5-pro'
  });

  return report;
}

// scripts/biomedical-research-workflow.ts

async function biomedicalResearchWorkflow(meshTerms: string[]) {
  // Step 1: Search PubMed with MeSH terms
  const pubmedResults = await mcp.invoke('pubmed_search', {
    mesh_terms: meshTerms,
    filters: {
      article_type: ['Clinical Trial', 'Meta-Analysis', 'Systematic Review'],
      publication_date: '2020-2025',
      species: 'Humans'
    }
  });

  // Step 2: Fetch full metadata
  const pmids = pubmedResults.map(r => r.pmid);
  const metadata = await mcp.invoke('fetch_pubmed_metadata', { pmids });

  // Step 3: Download PDFs via institutional access
  const authSession = await mcp.invoke('authenticate_institution', {
    institution: 'harvard',
    credentials: process.env.INSTITUTION_CREDS
  });

  await mcp.invoke('download_pubmed_pdfs', {
    pmids,
    auth_session: authSession
  });

  // Step 4: Extract outcome measures from clinical trials
  const outcomes = await Promise.all(
    metadata.map(async (paper) => {
      const analysis = await mcp.invoke('ask-gemini', {
        prompt: `Extract primary and secondary outcome measures from this clinical trial abstract:

                 ${paper.abstract}

                 Return structured data: intervention, control, primary_outcome, secondary_outcomes, results.`,
        model: 'gemini-2.5-pro'
      });
      return { ...paper, outcomes: analysis };
    })
  );

  return outcomes;
}

// utils/citation-formatter.ts - APA Style

const apaStyle = {
  book: (c) =>
    `${formatAuthors(c.authors, 'apa')}. (${c.year}). *${c.title}*. ${c.publisher}.`,

  article: (c) =>
    `${formatAuthors(c.authors, 'apa')}. (${c.year}). ${c.title}. *${c.journal}*, *${c.volume}*(${c.issue}), ${c.pages}.`,

  web: (c) =>
    `${formatAuthors(c.authors, 'apa')}. (${c.year}). ${c.title}. ${c.website}. ${c.url}`
};

// formatAuthors('apa') → "Smith, J., & Jones, A."

// utils/citation-formatter.ts - MLA Style

const mlaStyle = {
  book: (c) =>
    `${formatAuthors(c.authors, 'mla')}. *${c.title}*. ${c.publisher}, ${c.year}.`,

  article: (c) =>
    `${formatAuthors(c.authors, 'mla')}. "${c.title}." *${c.journal}*, vol. ${c.volume}, no. ${c.issue}, ${c.year}, pp. ${c.pages}.`,

  web: (c) =>
    `${formatAuthors(c.authors, 'mla')}. "${c.title}." *${c.website}*, ${c.year}, ${c.url}.`
};

// formatAuthors('mla') → "Smith, John, and Anne Jones."

// utils/citation-formatter.ts - Chicago Style

const chicagoStyle = {
  book: (c) =>
    `${formatAuthors(c.authors, 'chicago')}. *${c.title}*. ${c.place}: ${c.publisher}, ${c.year}.`,

  article: (c) =>
    `${formatAuthors(c.authors, 'chicago')}. "${c.title}." *${c.journal}* ${c.volume}, no. ${c.issue} (${c.year}): ${c.pages}.`,

  web: (c) =>
    `${formatAuthors(c.authors, 'chicago')}. "${c.title}." ${c.website}. Accessed ${c.access_date}. ${c.url}.`
};

// formatAuthors('chicago') → "Smith, John, and Anne Jones."

// utils/citation-formatter.ts - Nature Style

const natureStyle = {
  article: (c) =>
    `${formatAuthors(c.authors, 'nature')} ${c.title}. *${c.journal}* **${c.volume}**, ${c.pages} (${c.year}).`
};

// formatAuthors('nature') → "Smith, J. & Jones, A."

// utils/citation-formatter.ts - IEEE Style

const ieeeStyle = {
  article: (c) =>
    `${formatAuthors(c.authors, 'ieee')}, "${c.title}," *${c.journal}*, vol. ${c.volume}, no. ${c.issue}, pp. ${c.pages}, ${c.year}.`
};

// formatAuthors('ieee') → "J. Smith and A. Jones"

// integrations/obsidian-sync.ts

async function syncToObsidian(papers: Paper[], vaultPath: string) {
  for (const paper of papers) {
    const note = `
---
title: "${paper.title}"
authors: ${paper.authors.join(', ')}
year: ${paper.year}
tags: [${paper.keywords.map(k => `research/${k}`).join(', ')}]
doi: ${paper.doi}
---

# ${paper.title}

**Authors**: ${paper.authors.join(', ')}
**Year**: ${paper.year}
**DOI**: [${paper.doi}](https://doi.org/${paper.doi})

## Abstract

${paper.abstract}

## Key Findings

${paper.key_findings.map(f => `- ${f}`).join('\n')}

## Methodology

${paper.methodology_summary}

## My Notes

<!-- Add your notes here -->

## Related Papers

${paper.cited_by.map(c => `- [[${c.title}]]`).join('\n')}

## PDF

[Local PDF](file://${paper.pdf_path})
`;

    await fs.writeFile(
      `${vaultPath}/Research/${sanitizeFilename(paper.title)}.md`,
      note
    );
  }

  console.log(`Synced ${papers.length} papers to Obsidian vault`);
}

// integrations/notion-sync.ts

async function syncToNotion(papers: Paper[], notionToken: string, databaseId: string) {
  const notion = new Client({ auth: notionToken });

  for (const paper of papers) {
    await notion.pages.create({
      parent: { database_id: databaseId },
      properties: {
        Title: { title: [{ text: { content: paper.title } }] },
        Authors: { rich_text: [{ text: { content: paper.authors.join(', ') } }] },
        Year: { number: paper.year },
        DOI: { url: `https://doi.org/${paper.doi}` },
        Keywords: { multi_select: paper.keywords.map(k => ({ name: k })) },
        Status: { select: { name: 'To Read' } }
      },
      children: [
        {
          object: 'block',
          type: 'heading_2',
          heading_2: { rich_text: [{ text: { content: 'Abstract' } }] }
        },
        {
          object: 'block',
          type: 'paragraph',
          paragraph: { rich_text: [{ text: { content: paper.abstract } }] }
        },
        // Additional blocks for methodology, findings, etc.
      ]
    });
  }
}

// integrations/zotero-sync.ts

async function syncToZotero(papers: Paper[], zoteroLibrary: string) {
  const bibtexEntries = papers.map(paper => `
@article{${generateCiteKey(paper)},
  title = {${paper.title}},
  author = {${paper.authors.join(' and ')}},
  journal = {${paper.journal}},
  year = {${paper.year}},
  volume = {${paper.volume}},
  number = {${paper.issue}},
  pages = {${paper.pages}},
  doi = {${paper.doi}},
  file = {${paper.pdf_path}}
}
  `).join('\n\n');

  await fs.writeFile(
    `${zoteroLibrary}/auto-imported.bib`,
    bibtexEntries
  );

  console.log(`Generated BibTeX file with ${papers.length} entries`);
}

function generateCiteKey(paper: Paper): string {
  const firstAuthor = paper.authors[0].split(' ').pop().toLowerCase();
  return `${firstAuthor}${paper.year}${paper.title.split(' ')[0].toLowerCase()}`;
}