Academic research synthesis and citation-ready literature review from PDF papers

Academic research can feel like drowning in paper. You find five relevant PDFs, but extracting the core insights, comparing arguments across sources, and building a unified literature review means hours of copying, pasting, and manual note-taking. Each paper demands separate attention; insights stay siloed in individual documents; citations scatter across notebooks or half-finished spreadsheets....... For more on this, see Academic research paper summarisation and citation extrac.... For more on this, see Academic literature review synthesis from research papers.

What if you could submit a folder of research papers and receive a synthesised literature review with proper citations, ready to paste into your work? No jumping between tools. No retyping findings. No hunting for page numbers to cite. The workflow exists today, and you can build it in under an hour.

This Alchemy guide shows you how to wire three AI tools together so that PDFs become structured research summaries automatically. You upload papers once, and the system extracts key arguments, cross-references them, and produces a citation-ready document. We'll focus on beginner-friendly orchestration because the complexity here isn't technical; it's about knowing which tool does what and when to call it.

The Automated Workflow

The workflow has three distinct phases: extraction, summarisation, and synthesis. Each phase uses a different tool, and an orchestration layer connects them so data flows without manual intervention.

Phase 1:

Extract Key Arguments from Each Paper (Chat-with-PDF-by-Copilotus)

When a PDF arrives, Chat-with-PDF-by-Copilotus reads the full document and responds to your questions about its content. Unlike basic PDF readers, this tool understands context across pages, so you can ask complex questions like "What methodology did the authors use?" or "What are the main limitations the authors acknowledge?"

The first step is to upload a PDF and ask consistent questions. This produces structured data about each paper.

Phase 2:

Simplify Complex Passages (ExplainPaper)

Some papers contain dense methodology sections or technical explanations that are hard to summarise accurately. ExplainPaper takes a specific passage and rewrites it in clearer language, preserving accuracy whilst removing jargon. This step ensures your final review explains concepts clearly enough for readers unfamiliar with the original papers.

Phase 3:

Generate Summaries (Smmry)

Smmry condenses longer passages into bullet-point summaries at a specified length. This is useful for creating the final synthesis document, where you want key findings distilled to their essentials.

Choosing Your Orchestration Tool

For this workflow, we'll use n8n as the primary example because it has the best free tier for testing and good HTTP request support. However, Zapier, Make, and Claude Code all work equally well; we'll note key differences below.

n8n is self-hosted or cloud-hosted; free accounts get 1,000 executions per month. Zapier is simpler visually but more expensive at scale. Make sits between them, offering good visual building with reasonable pricing. Claude Code is ideal if you prefer Python and want to run everything via API calls.

Building the Workflow in n8n

Start by creating a new workflow in n8n. The flow looks like this:

1. Trigger: Receive a PDF file (via webhook or file upload node)
2. Step 1: Send the PDF to Chat-with-PDF-by-Copilotus
3. Step 2: Extract the response and send relevant passages to ExplainPaper
4. Step 3: Pass simplified text to Smmry
5. Step 4: Format output as a structured literature review entry
6. Step 5: Append to a Google Sheet or send to your email

Below is the specific configuration for each step.

Step 1: Webhook Trigger

First, create a webhook that accepts PDF file uploads. In n8n, add a Webhook node and configure it to accept POST requests.

Copy
Method: POST
Path: /academic-research-intake
Authentication: None (for testing; add authentication in production)

When you POST a PDF to this webhook, n8n will receive it. Store the file in a temporary location so later steps can access it.

Step 2: Call Chat-with-PDF-by-Copilotus API

Chat-with-PDF-by-Copilotus provides an API endpoint for uploading PDFs and querying them. You'll need an API key; sign up at their website to obtain one.

The endpoint structure is:

Copy
POST https://api.copilotus.app/v1/pdf/upload
Authorization: Bearer YOUR_API_KEY
Content-Type: multipart/form-data

In n8n, add an HTTP Request node and configure it like this:

Copy{
  "method": "POST",
  "url": "https://api.copilotus.app/v1/pdf/upload",
  "headers": {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "multipart/form-data"
  },
  "body": {
    "file": "{{ $binary.data }}"
  }
}

The response includes a document_id. Store this value because you'll use it in the next request to ask questions about the paper.

Next, add another HTTP Request node to query the PDF. This node should ask structured questions to extract the paper's main findings:

Copy{
  "method": "POST",
  "url": "https://api.copilotus.app/v1/pdf/query",
  "headers": {
    "Authorization": "Bearer YOUR_API_KEY"
  },
  "body": {
    "document_id": "{{ $prev.body.document_id }}",
    "questions": [
      "What is the primary research question or hypothesis?",
      "What methodology did the authors use?",
      "What are the main findings?",
      "What are the study's limitations?",
      "What are the key citations this paper makes?"
    ]
  }
}

This returns structured answers. Parse the response and extract each answer into separate variables.

Step 3: Clarify Technical Passages with ExplainPaper

ExplainPaper works best when you feed it a specific passage, not an entire paper. Filter the findings from Step 2 and identify any that contain technical language or methodology jargon. For each, send the passage to ExplainPaper.

The ExplainPaper API endpoint is:

Copy
POST https://api.explainpaper.com/v1/explain
Authorization: Bearer YOUR_API_KEY
Content-Type: application/json

Configure an HTTP Request node:

Copy{
  "method": "POST",
  "url": "https://api.explainpaper.com/v1/explain",
  "headers": {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json"
  },
  "body": {
    "text": "{{ $prev.methodology }}",
    "length": "medium"
  }
}

The response is a simplified explanation of the methodology. Store this in a variable called simplified_methodology.

Step 4: Summarise Findings with Smmry

Smmry has a straightforward API. Send it text and specify how many sentences you want in the summary.

Copy
POST https://api.smmry.com/SM_API
Content-Type: application/x-www-form-urlencoded

In n8n:

Copy{
  "method": "POST",
  "url": "https://api.smmry.com/SM_API",
  "body": {
    "sm_api_input": "{{ $prev.simplified_methodology }}",
    "sm_api_number": 3
  }
}

This returns a 3-sentence summary. Repeat this node for other sections: findings, limitations, and key insights.

Step 5: Format as Structured Literature Review Entry

Now you have all the components. Assemble them into a structured entry with proper formatting for easy citation.

Add a Function node to format the data:

Copyconst entry = {
  title: $input.first().body.title,
  authors: $input.first().body.authors,
  year: $input.first().body.year,
  doi: $input.first().body.doi,
  research_question: $input.first().body.research_question,
  methodology: $input.prev().body.explanation,
  key_findings: $input.first().body.summary_findings,
  limitations: $input.first().body.summary_limitations,
  citations: $input.first().body.citations,
  formatted_citation: `${$input.first().body.authors} (${$input.first().body.year}). ${$input.first().body.title}. ${$input.first().body.journal}, ${$input.first().body.volume}(${$input.first().body.issue}), ${$input.first().body.pages}. https://doi.org/${$input.first().body.doi}`
};

return entry;

Step 6: Send to Google Sheets or Email

Finally, append this entry to a Google Sheet or email it to yourself. Add a Google Sheets node:

Copy{
  "operation": "appendOrUpdateRow",
  "spreadsheetId": "YOUR_SHEET_ID",
  "range": "Literature Review!A:H",
  "values": {
    "Title": "{{ $prev.title }}",
    "Authors": "{{ $prev.authors }}",
    "Year": "{{ $prev.year }}",
    "Research Question": "{{ $prev.research_question }}",
    "Methodology": "{{ $prev.methodology }}",
    "Key Findings": "{{ $prev.key_findings }}",
    "Limitations": "{{ $prev.limitations }}",
    "Citation": "{{ $prev.formatted_citation }}"
  }
}

Save the workflow and activate it. Now, whenever you POST a PDF to the webhook URL, the system processes it end-to-end.

Testing the Workflow

To test, use a tool like Postman or curl:

Copycurl -X POST http://localhost:5679/webhook/academic-research-intake \
  -F "file=@paper.pdf" \
  -H "Content-Type: multipart/form-data"

Watch the n8n execution logs to verify each step completes successfully.

Alternative:

Using Make (Integromat)

If you prefer a visual interface with higher rate limits, Make is simpler to set up. The steps are identical; only the node configuration differs slightly.

In Make, create a new scenario. Add a Webhooks module to receive the PDF, then use HTTP Request modules for each API call. Make's visual flow builder is more intuitive for beginners, though it charges per operation rather than per execution.

Alternative:

Using Claude Code

For developers, Claude Code offers the most flexibility. You write a Python script that calls each API in sequence:

Copyimport requests
import json

api_key_copilotus = "YOUR_KEY"
api_key_explainpaper = "YOUR_KEY"

pdf_path = "paper.pdf"
with open(pdf_path, "rb") as f:
    response = requests.post(
        "https://api.copilotus.app/v1/pdf/upload",
        headers={"Authorization": f"Bearer {api_key_copilotus}"},
        files={"file": f}
    )
    document_id = response.json()["document_id"]

# Query the PDF
response = requests.post(
    "https://api.copilotus.app/v1/pdf/query",
    headers={"Authorization": f"Bearer {api_key_copilotus}"},
    json={
        "document_id": document_id,
        "questions": [
            "What is the primary research question?",
            "What are the main findings?"
        ]
    }
)
findings = response.json()["answers"]

# Explain methodology
response = requests.post(
    "https://api.explainpaper.com/v1/explain",
    headers={"Authorization": f"Bearer {api_key_explainpaper}"},
    json={"text": findings["methodology"], "length": "medium"}
)
simplified = response.json()["explanation"]

print(json.dumps({"research": findings, "simplified": simplified}, indent=2))

Run this script on a schedule (e.g., every hour) to process batches of PDFs.

The Manual Alternative

You don't need orchestration if you process one or two papers occasionally. The manual route is straightforward:

1. Open Chat-with-PDF-by-Copilotus in your browser, upload a PDF, and ask your questions directly. Copy the answers into a document.

2. For dense passages, paste them into ExplainPaper and copy the simplified version.

3. Paste findings into Smmry to condense them.

4. Manually assemble everything into your literature review, adding citations by hand.

This approach takes 15-20 minutes per paper but requires no technical setup. Use it if you're processing fewer than five papers, or if you want to manually verify each step before automating. Once you're confident in the quality, automate the workflow.

Pro Tips

Error Handling and Rate Limits

All three APIs have rate limits. Chat-with-PDF-by-Copilotus typically allows 100 requests per day on the free tier; ExplainPaper and Smmry are more generous. In your n8n workflow, add a Wait node between API calls to space them out:

Copy{
  "type": "wait",
  "duration": 2000
}

This adds a 2-second delay between requests, preventing rate limit errors. Monitor API usage in your n8n execution history and adjust durations if needed.

Verify Accuracy at Scale

Automated summaries are good, but not perfect. Before processing 50 papers, run 3 test papers manually and compare the automated output to your own summary. Look for missed nuances or over-simplified findings. Adjust your questions to Chat-with-PDF-by-Copilotus if certain topics aren't captured well.

Cost Optimisation

If you're processing many papers, the API costs add up. Prioritise which papers get the full treatment. For preliminary screening, use only Smmry to generate quick abstracts; reserve the full workflow for papers you plan to cite. This reduces per-paper cost from roughly £0.15 to £0.03.

Export Format Matters

Store your literature review in Google Sheets, not a text file. Sheets makes it easy to sort by year, search for keywords, and share with collaborators. If you need to export later, Google Sheets integrates with citation managers like Zotero via extensions.

Iterate on Questions

The quality of your literature review depends on the questions you ask Chat-with-PDF-by-Copilotus. Start generic ("What are the main findings?"), then refine based on your research focus. If you're studying climate policy, ask "What policy recommendations do the authors make?" rather than relying on general summaries.

Cost Breakdown

If you're a student, many universities provide free or discounted access to academic databases and tools. Check before subscribing.