Agentic AI for Automated Literature Review Synthesis

Built for the NVIDIA & AWS Agentic AI Unleashed Hackathon 2025

Last Updated: 2025-01-15

ResearchOps Agent is a multi-agent AI system that automatically synthesizes research literature, transforming hours of manual literature review into minutes of automated analysis.

The Problem: Academic researchers spend 40% of their time on literature review, manually reading, extracting, and synthesizing information from dozens of papers.

Our Solution: An autonomous multi-agent system that:

• 🔍 Searches and retrieves relevant papers using semantic similarity
• 📊 Extracts structured information in parallel using reasoning AI
• 🧩 Synthesizes findings across papers to identify themes, contradictions, and gaps
• 📋 Generates comprehensive literature reviews automatically

Impact: Reduces literature review time from 8+ hours to 2-3 minutes.

✅ llama-3.1-nemotron-nano-8B-v1 (Reasoning NIM)

• Deployed as NVIDIA NIM inference microservice
• Used for: Paper analysis, cross-document reasoning, synthesis generation
• Endpoint: http://reasoning-nim:8000/v1/completions

✅ nv-embedqa-e5-v5 (Retrieval Embedding NIM)

• Deployed as NVIDIA NIM inference microservice
• Used for: Query embedding, paper similarity, finding clustering
• Endpoint: http://embedding-nim:8001/v1/embeddings

✅ Amazon EKS Deployment

• Multi-container orchestration on Amazon Elastic Kubernetes Service
• GPU instances: 2x g5.2xlarge
• Production-ready with health checks, persistence, load balancing

✅ Agentic Application

• 4 autonomous agents with distinct roles and decision-making
• Agents: Scout (retrieval), Analyst (extraction), Synthesizer (reasoning), Coordinator (orchestration)
• Demonstrates true agency: autonomous search expansion, quality self-evaluation, dynamic refinement

┌────────────────────────────────────────────────────────────┐
│                      Amazon EKS Cluster                     │
│                                                             │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐  │
│  │Reasoning │  │Embedding │  │  Qdrant  │  │  Agent   │  │
│  │   NIM    │  │   NIM    │  │ Vector DB│  │Orchestr. │  │
│  │          │  │          │  │          │  │          │  │
│  │ llama-3.1│  │nv-embed  │  │  Papers  │  │ 4 Agents │  │
│  │ nemotron │  │ qa-e5-v5 │  │Embeddings│  │ LangGraph│  │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬─────┘  │
│       │             │              │             │         │
│       └─────────────┴──────────────┴─────────────┘         │
│                          │                                  │
│                          ▼                                  │
│                   ┌──────────┐                              │
│                   │  Web UI  │                              │
│                   │(Streamlit)                              │
│                   └──────────┘                              │
└────────────────────────────────────────────────────────────┘

See Architecture_Diagrams.md for detailed diagrams.

Scout Agent (Retrieval)

• Uses Embedding NIM to find relevant papers
• Semantic search across 7 academic databases:
  • arXiv (CS, Physics, Math)
  • PubMed (Biomedical)
  • Semantic Scholar (Multi-disciplinary, free)
  • Crossref (Metadata & citations)
  • IEEE Xplore (Engineering, optional)
  • ACM Digital Library (Computer Science, optional)
  • SpringerLink (Multi-disciplinary, optional)
• Parallel searches across all enabled sources
• Autonomous relevance filtering

Analyst Agent (Extraction)

• Uses Reasoning NIM to extract structured info
• Parallel processing of multiple papers
• Extracts: methodology, findings, limitations

Synthesizer Agent (Reasoning)

• Uses BOTH NIMs for cross-document analysis
• Identifies themes (embedding clustering)
• Finds contradictions (reasoning)
• Identifies research gaps (reasoning)

Coordinator Agent (Orchestration)

• Uses Reasoning NIM for meta-decisions
• Decides: search more papers? synthesis complete?
• Autonomous workflow control

📚 For complete setup and submission guide, see: HACKATHON_SETUP_GUIDE.md
This includes step-by-step instructions from account setup to Devpost submission.

• AWS Account with EKS access
• NVIDIA NGC Account (signup here)
• kubectl installed
• eksctl installed
• Docker installed

⏱️ Setup Time: 2-3 hours (first time)
📖 Detailed Guide: See HACKATHON_SETUP_GUIDE.md

git clone https://github.com/yourusername/research-ops-agent
cd research-ops-agent

# Copy secrets template
cp k8s/secrets.yaml.template k8s/secrets.yaml

# Edit with your credentials
nano k8s/secrets.yaml
# Add: NGC_API_KEY, AWS credentials

export NGC_API_KEY="your_ngc_api_key_here"
export AWS_ACCESS_KEY_ID="your_aws_key"
export AWS_SECRET_ACCESS_KEY="your_aws_secret"
export AWS_DEFAULT_REGION="us-east-1"

cd k8s
chmod +x deploy.sh
./deploy.sh

This will:

• Create EKS cluster (15-20 minutes) or use existing
• Deploy both NVIDIA NIMs
• Deploy vector database
• Deploy agent orchestrator
• Deploy web UI
• Display service endpoints

# Port-forward for local access
kubectl port-forward -n research-ops svc/web-ui 8501:8501

# Open browser to: http://localhost:8501

Or if using LoadBalancer:

# Get Web UI URL
kubectl get svc web-ui -n research-ops -o jsonpath='{.status.loadBalancer.ingress[0].hostname}'

# Open the displayed URL in your browser

📚 For detailed deployment instructions, troubleshooting, and submission guide, see: HACKATHON_SETUP_GUIDE.md

1. Enter your research query (e.g., "machine learning for medical imaging")
2. Click "Start Research"
3. Watch agents work in real-time
4. Receive comprehensive literature review in 2-3 minutes

import requests

response = requests.post(
    "http://your-api-url/research",
    json={"query": "machine learning for medical imaging"}
)

result = response.json()
print(f"Papers analyzed: {result['papers_analyzed']}")
print(f"Common themes: {result['common_themes']}")
print(f"Research gaps: {result['research_gaps']}")

from research_ops import ResearchOpsAgent
from nim_clients import ReasoningNIMClient, EmbeddingNIMClient

# Initialize clients
async with ReasoningNIMClient() as reasoning, \
            EmbeddingNIMClient() as embedding:

    # Create agent
    agent = ResearchOpsAgent(reasoning, embedding)

    # Run research synthesis
    result = await agent.run("your research query here")

    print(result)

research-ops-agent/
├── k8s/                          # Kubernetes manifests
│   ├── namespace.yaml            # Namespace definition
│   ├── secrets.yaml              # API keys and credentials
│   ├── reasoning-nim-deployment.yaml
│   ├── embedding-nim-deployment.yaml
│   ├── vector-db-deployment.yaml
│   ├── agent-orchestrator-deployment.yaml
│   ├── web-ui-deployment.yaml
│   └── deploy.sh                 # One-command deployment
│
├── src/                          # Application code
│   ├── nim_clients.py            # NIM API wrappers
│   ├── agents.py                 # Multi-agent implementation
│   └── test_integration.py       # Integration tests
│
├── docs/                         # Documentation
│   ├── Architecture_Diagrams.md  # System architecture
│   └── EKS_vs_SageMaker_Comparison.md
│
└── README.md                     # This file

3-minute demo video showcasing:

0:00-0:30 - The Problem

• Researcher overwhelmed by 50+ papers
• Manual process takes 8 hours

0:30-1:30 - Agent Workflow (Key Section)

• Scout Agent: Semantic search with Embedding NIM
• Analyst Agent: Parallel extraction with Reasoning NIM
• Synthesizer Agent: Cross-document reasoning
• Coordinator: Autonomous decisions
• Shows both NIMs in action!

1:30-2:00 - Results

• Generated literature review
• 8 hours → 3 minutes

2:00-2:45 - Technical Architecture

• EKS deployment with GPU instances
• Multi-agent orchestration
• Cost optimization: $0.15 per query

2:45-3:00 - Impact & Future

• Academic, corporate R&D use cases
• Extensible to other domains

Reasoning NIM (llama-3.1-nemotron-nano-8B-v1)

• Text completion and chat interfaces
• Structured information extraction
• Cross-document reasoning
• Contradiction identification
• Research gap analysis

Embedding NIM (nv-embedqa-e5-v5)

• 1024-dimension embeddings
• Query vs passage optimization
• Batch processing (32 texts/call)
• Cosine similarity calculation
• Semantic clustering

Infrastructure

• 2x g5.2xlarge GPU instances (NVIDIA A10G)
• Kubernetes 1.28
• Auto-scaling enabled
• Multi-zone deployment

Cost Optimization

• Development: build.nvidia.com (free)
• Testing: Time-boxed EKS sessions
• Production: ~$14 total cost (well under $100 budget)

Production Features

• Health checks and liveness probes
• Persistent storage for model caches
• LoadBalancer for external access
• Horizontal Pod Autoscaling

Development Phase (30 hours): $0 (build.nvidia.com) Integration & Testing (6 hours): ~$7 Demo & Video (2 hours): ~$2 Buffer for issues: ~$4 Total AWS Cost: ~$13 / $100 budget

Per-Query Cost in Production:

• Embedding NIM: ~$0.05
• Reasoning NIM: ~$0.08
• Infrastructure: ~$0.02
• Total: $0.15 per research synthesis

• ✅ Production-grade Kubernetes deployment
• ✅ Proper use of both required NIMs
• ✅ Multi-container orchestration
• ✅ Health checks, persistence, monitoring
• ✅ Cost-optimized architecture

• ✅ Clean, intuitive web interface
• ✅ Real-time agent activity visualization
• ✅ Reasoning transparency
• ✅ Responsive design
• ✅ Comprehensive error handling

• ✅ Massive time savings (97% reduction)
• ✅ Large addressable market (millions of researchers)
• ✅ Quantifiable ROI ($200-400 saved per review)
• ✅ Extensible to other domains
• ✅ Production-ready architecture

• ✅ Novel: True multi-agent collaboration
• ✅ Not just "another chatbot"
• ✅ Demonstrates agentic behavior
• ✅ Clear reasoning visibility
• ✅ Solves real, painful problem

Short-term:

• Support for more academic databases (IEEE, Springer, etc.)
• Export to multiple formats (PDF, LaTeX, Markdown)
• Citation management integration (Zotero, Mendeley)
• Multi-language support

Medium-term:

• Collaborative research workflows
• Version control for literature reviews
• Integration with research writing tools
• Custom agent training for specialized domains

Long-term:

• Hypothesis generation from gaps
• Experiment design suggestions
• Automated grant proposal drafting
• Research trend prediction

• Your Name - Lead Developer & Architect
• Built for NVIDIA & AWS Agentic AI Unleashed Hackathon 2025

MIT License - see LICENSE file for details

• NVIDIA for NIM inference microservices
• AWS for EKS infrastructure
• Devpost for hosting the hackathon
• Research community for inspiration

• GitHub: @yourusername
• Email: your.email@example.com
• Demo Video: [YouTube Link]
• Devpost: [Submission Link]

Live Demo: http://your-demo-url.com

# Check pod status
kubectl get pods -n research-ops

# Check logs
kubectl logs -f deployment/reasoning-nim -n research-ops
kubectl logs -f deployment/embedding-nim -n research-ops

# Test endpoints
kubectl port-forward svc/reasoning-nim 8000:8000 -n research-ops
curl http://localhost:8000/v1/health/live

kubectl port-forward svc/embedding-nim 8001:8001 -n research-ops
curl http://localhost:8001/v1/health/live

# Check current spending
aws ce get-cost-and-usage --time-period Start=2025-10-01,End=2025-11-01 \
  --granularity DAILY --metrics BlendedCost

# Stop cluster when not using
eksctl delete cluster --name research-ops-cluster --region us-east-1

See DOCUMENTATION_INDEX.md for a complete guide to all documentation.

• Quick Start Guide - 3-day timeline and essential commands
• Status & Features - Current project status and capabilities
• Hackathon Setup Guide - Complete setup and submission guide
• Deployment Guide - Kubernetes deployment instructions
• Testing Guide - Testing with mock vs live services
• Docker Testing - Docker-based testing guide

• Architecture Diagrams - Complete system diagrams
• EKS vs SageMaker - Deployment comparison
• API Keys Setup - Configuration for data sources (7 sources)
• Paper Sources - Academic database integration (7 sources)
• Troubleshooting - Common issues and solutions
• AWS Setup - AWS credentials configuration
• Documentation Index - Complete docs directory guide

Built with ❤️ for the research community

Making literature review delightful, one paper at a time.