Academic Research Agents

A multi-agent AI system for academic paper search, PDF parsing, structured paper analysis, and literature review synthesis.

Overview

Academic Research Agents is a research assistant built with CrewAI, LangGraph, ChromaDB, and Streamlit. It helps automate the workflow of:

1. Searching for relevant academic papers
2. Downloading and parsing PDF papers into Markdown
3. Extracting structured paper information
4. Synthesizing a literature review
5. Critiquing the generated review and revising it when needed
6. Saving analyzed papers into a local knowledge base for later semantic search

The system is designed for academic workflows such as literature review, paper comparison, and research note generation.

Key Features

• Multi-agent workflow powered by LangGraph

• Academic paper search using DuckDuckGo and scholar-oriented queries

• PDF download and parsing with automatic fallback:

  • Marker-based parsing for higher quality extraction
  • PyMuPDF4LLM fallback for reliability

• Structured paper analysis with Pydantic schema validation

• Literature review synthesis from multiple papers

• Critique and revision loop to reduce hallucinations and improve quality

• Local knowledge base powered by ChromaDB

• Semantic search / RAG over previously analyzed papers

• Streamlit web interface for interactive use

• Support for local Ollama models and optional Groq models

Project Structure

academic-research-agents/
├── app.py                         # Streamlit UI entry point
├── pyproject.toml                 # Project dependencies and metadata
├── src/
│   ├── agents/
│   │   ├── search_agent.py
│   │   ├── parser_agent.py
│   │   ├── analyzer_agent.py
│   │   ├── synthesizer_agent.py
│   │   └── critic_agent.py
│   ├── graph/
│   │   ├── state.py
│   │   ├── nodes.py
│   │   └── workflow.py
│   ├── models/
│   │   └── paper_analysis.py
│   ├── tools/
│   │   ├── duckduckgo_tool.py
│   │   ├── paper_reader_tool.py
│   │   ├── pdf_parser_tool.py
│   │   └── ...
│   └── utils/
│       ├── llm_config.py
│       └── knowledge_base.py
├── data/
│   ├── papers/                    # Downloaded PDFs
│   ├── markdown/                  # Parsed Markdown files
│   └── chroma_db/                 # Local vector database
├── docs/                          # Documentation notes
└── poc/                           # Proof-of-concept / test scripts

Workflow

The main pipeline is organized as follows:

1. Search

The search agent finds relevant academic papers using DuckDuckGo-based search tools.

2. Parse

The parser agent downloads PDF papers and converts them into Markdown.

3. Analyze

The analyzer agent extracts structured information from each paper, including:

• metadata
• research problem
• methodology
• experimental setup
• key findings
• critical analysis
• relevance score
• novelty score

4. Synthesize

The synthesizer agent combines multiple analyses into a coherent literature review.

5. Critique

The critic agent checks the generated review for unsupported claims and citation issues. If issues are found, the system can loop back and revise the review.

6. Save to Knowledge Base

The final analysis is stored in ChromaDB for semantic retrieval and future RAG queries.

Tech Stack

• Python 3.11+
• CrewAI
• LangGraph
• Streamlit
• ChromaDB
• Ollama
• Groq
• DuckDuckGo Search
• Marker PDF
• PyMuPDF4LLM
• Pydantic
• Rich

Prerequisites

Before running the project, make sure you have:

• Python 3.11 or newer
• Ollama installed and running locally
• At least one Ollama model pulled
• Optional: a Groq API key for creative/backup LLM usage
• Optional: CUDA-capable GPU for better PDF parsing performance with Marker

Recommended Ollama models

The code defaults to:

• qwen2.5:14b-instruct-q5_K_M for generation
• nomic-embed-text for embeddings

You may change these through environment variables.

Installation

1. Clone the repository

git clone <your-repo-url>
cd academic-research-agents

2. Create a virtual environment

python -m venv .venv

Activate it:

# Windows
.venv\Scripts\activate

# macOS / Linux
source .venv/bin/activate

3. Install dependencies

Using uv:

uv sync

Or using pip:

pip install -e .

4. Prepare Ollama models

Pull the required models:

ollama pull qwen2.5:14b-instruct-q5_K_M
ollama pull nomic-embed-text

If you use a different model name, update the environment variable:

OLLAMA_MODEL=your-model-name

Environment Variables

Create a .env file in the project root:

OLLAMA_BASE_URL=http://localhost:11434
OLLAMA_MODEL=qwen2.5:14b-instruct-q5_K_M
GROQ_API_KEY=your_groq_api_key
SEMANTIC_SCHOLAR_API_KEY=your_semantic_scholar_api_key

Notes

• OLLAMA_BASE_URL controls the local Ollama endpoint.
• OLLAMA_MODEL sets the main local LLM.
• GROQ_API_KEY is used for optional Groq-based models.
• SEMANTIC_SCHOLAR_API_KEY is included for academic API support if needed.

Running the App

Start the Streamlit interface with:

streamlit run app.py

Then open the local URL shown in the terminal.

Main UI Modes

The Streamlit app provides multiple modes, including:

• Academic Research Assistant: Full multi-agent pipeline
• Semantic Search (RAG): Query the local knowledge base
• View Knowledge Base: Inspect stored papers and database statistics

Outputs

The system generates:

• Downloaded PDFs in data/papers/
• Parsed Markdown papers in data/markdown/
• Stored embeddings and metadata in data/chroma_db/
• Literature review output in the UI
• Cached analysis data for reuse

Typical Use Case

Example workflow:

1. Enter a research topic in the UI
2. Let the system search for related papers
3. Parse and analyze the selected papers
4. Generate a literature review
5. Review the critique output
6. Save the result into the knowledge base for later semantic search

Notes on PDF Parsing

The parser tries the following strategy:

1. Marker first, for higher-quality layout extraction and formula preservation
2. PyMuPDF4LLM as a fallback if Marker fails

This makes the pipeline more robust across different PDF layouts, including:

• two-column papers
• papers with tables
• papers with equations
• scanned or complex layouts

Knowledge Base

The project uses ChromaDB as a local vector database.

It stores each paper as a text document built from:

• title
• authors
• venue
• year
• research problem
• methodology
• datasets
• evaluation metrics
• findings
• strengths and limitations

This enables semantic search and RAG-style question answering over previously processed papers.

Development and Test Scripts

The poc/ folder contains experimental and test scripts for:

• arXiv search
• PDF parsing
• knowledge base testing
• LangGraph testing
• local stack validation
• full pipeline testing

These scripts are useful for debugging individual components before running the full app.

Troubleshooting

Ollama connection errors

Make sure Ollama is running locally and reachable at the configured base URL.

Missing model errors

Pull the required model with ollama pull ... or update OLLAMA_MODEL.

PDF parsing issues

If Marker fails, the system automatically falls back to PyMuPDF4LLM.

ChromaDB errors

Delete data/chroma_db/ and rerun the pipeline if the database becomes corrupted.

Windows file lock issues

If the knowledge base cannot be deleted, close any running Python/Streamlit process that may still be holding the database files.

Author

Created as an academic research assistant project for automated literature review and paper analysis.