How to Build an AI Academic Research Assistant That Finds and Summarises Papers

ai-academic-assistant/
├── app/
│   ├── __init__.py
│   ├── openalex_client.py
│   ├── schemas.py
│   └── bibtex_verifier.py
├── tests/
│   └── test_academic_assistant.py
└── requirements.txt

from typing import Dict, List, Optional, Any
import httpx
from pydantic import BaseModel

class ScholarlyPaper(BaseModel):
    work_id: str
    doi: Optional[str]
    title: str
    publication_year: int
    authors: List[str]
    venue: str
    cited_by_count: int
    abstract_text: str
    open_access_pdf_url: Optional[str] = None

def reconstruct_inverted_abstract(inverted_index: Optional[Dict[str, List[int]]]) -> str:
    """Deterministically reconstructs plaintext abstract from OpenAlex abstract_inverted_index."""
    if not inverted_index:
        return ""
    position_map: Dict[int, str] = {}
    for word, positions in inverted_index.items():
        for pos in positions:
            position_map[pos] = word
    if not position_map:
        return ""
    sorted_indices = sorted(position_map.keys())
    return " ".join(position_map[i] for i in sorted_indices)

async def search_openalex_works(
    query: str,
    polite_email: str,
    max_results: int = 5,
    min_year: int = 2020,
) -> List[ScholarlyPaper]:
    """Queries OpenAlex /works API using the polite pool (mailto parameter)."""
    params = {
        "search": query,
        "filter": f"publication_year:>={min_year}",
        "per-page": max_results,
        "mailto": polite_email,
    }
    async with httpx.AsyncClient(timeout=15.0) as client:
        resp = await client.get("https://api.openalex.org/works", params=params)
        resp.raise_for_status()
        data = resp.json()

    papers: List[ScholarlyPaper] = []
    for item in data.get("results", []):
        authors = [
            a.get("author", {}).get("display_name", "Unknown")
            for a in item.get("authorships", [])[:6]
        ]
        primary_loc = item.get("primary_location") or {}
        source_info = primary_loc.get("source") or {}
        venue_name = source_info.get("display_name") or "Preprint / Unknown Venue"
        oa_info = item.get("open_access") or {}

        papers.append(
            ScholarlyPaper(
                work_id=item.get("id", ""),
                doi=item.get("doi"),
                title=item.get("title") or "Untitled",
                publication_year=int(item.get("publication_year") or 0),
                authors=authors,
                venue=venue_name,
                cited_by_count=int(item.get("cited_by_count") or 0),
                abstract_text=reconstruct_inverted_abstract(item.get("abstract_inverted_index")),
                open_access_pdf_url=oa_info.get("oa_url"),
            )
        )
    return papers

import re
from typing import List, Dict
from pydantic import BaseModel, Field
from app.openalex_client import ScholarlyPaper

class PaperMethodologyComparison(BaseModel):
    work_id: str
    doi: str
    core_methodology: str = Field(..., description="Architecture or statistical method used.")
    datasets_evaluated: List[str]
    primary_quantitative_result: str = Field(..., description="Exact metric and value reported, e.g. 'F1 = 89.4% on SciERC'")
    stated_limitations: str

def generate_verified_bibtex(paper: ScholarlyPaper) -> str:
    """Generates a deterministic BibTeX entry strictly from verified OpenAlex/Crossref metadata."""
    first_author_last = paper.authors[0].split()[-1].lower() if paper.authors else "unknown"
    clean_author = re.sub(r"[^a-z0-9]", "", first_author_last)
    cite_key = f"{clean_author}{paper.publication_year}"
    author_str = " and ".join(paper.authors) if paper.authors else "Unknown"
    doi_line = f"  doi = {{{paper.doi}}},\n" if paper.doi else ""

    return (
        f"@article{{{cite_key},\n"
        f"  title = {{{paper.title}}},\n"
        f"  author = {{{author_str}}},\n"
        f"  journal = {{{paper.venue}}},\n"
        f"  year = {{{paper.publication_year}}},\n"
        f"{doi_line}"
        f"}}"
    )

def verify_inline_doi_citations(review_markdown: str, verified_papers: Dict[str, ScholarlyPaper]) -> List[str]:
    """Checks that every cited DOI or work_id in the literature review exists in the retrieved paper registry."""
    cited_dois = re.findall(r"https://doi\.org/[^\s\)\]]+", review_markdown)
    known_dois = {p.doi for p in verified_papers.values() if p.doi}
    unverified = [d for d in cited_dois if d not in known_dois]
    return unverified

from app.openalex_client import reconstruct_inverted_abstract, ScholarlyPaper
from app.bibtex_verifier import generate_verified_bibtex, verify_inline_doi_citations

def test_reconstruct_openalex_inverted_abstract():
    inv = {
        "Graph": [0],
        "neural": [1],
        "networks": [2, 6],
        "model": [3],
        "ecological": [4],
        "food": [5],
    }
    text = reconstruct_inverted_abstract(inv)
    assert text == "Graph neural networks model ecological food networks"

def test_verified_bibtex_and_doi_checker():
    paper = ScholarlyPaper(
        work_id="https://openalex.org/W123",
        doi="https://doi.org/10.1038/s41586-025-00001-x",
        title="Topological Learning in Trophic Networks",
        publication_year=2025,
        authors=["Aniket Thakur", "Kenji Sato"],
        venue="Nature Machine Intelligence",
        cited_by_count=42,
        abstract_text="We introduce an attention-based GNN...",
    )
    bibtex = generate_verified_bibtex(paper)
    assert "@article{thakur2025," in bibtex
    assert "doi = {https://doi.org/10.1038/s41586-025-00001-x}" in bibtex

    registry = {paper.work_id: paper}
    review = (
        "Recent work ([Thakur & Sato, 2025](https://doi.org/10.1038/s41586-025-00001-x)) "
        "and a hallucinated citation ([Fake, 2024](https://doi.org/10.9999/fake.123))."
    )
    unverified = verify_inline_doi_citations(review, registry)
    assert unverified == ["https://doi.org/10.9999/fake.123"]