Autonomous Multi-Agent Research Report Generation System

---

1. Introduction

Large Language Models are powerful at generating text, but they struggle with structured reasoning, source grounding, and evidence validation when working alone. A single-agent system often blends planning, retrieval, verification, and writing into one opaque process — leading to hallucinations and weak source attribution.

This project presents an Autonomous Multi-Agent Research Report Generation System built using LangGraph orchestration, ChromaDB-based RAG, DuckDuckGo web search integration, FastAPI for REST API, and Streamlit for interactive UI. The system decomposes research into structured steps executed by specialized agents, ensuring modular reasoning, traceability, and evidence-backed output.

The goal is to generate structured, citation-supported research reports from a user-provided topic using coordinated multi-agent collaboration. It supports multiple LLMs (OpenAI, Groq, Google Gemini) and provides outputs in Markdown and PDF formats.

2. Problem Statement

Generating high-quality research reports requires:

• Topic decomposition
• Reliable information retrieval
• Evidence validation
• Structured synthesis
• Clear source attribution

Traditional LLM pipelines attempt to perform these steps in a single chain, leading to:

• Hallucinated claims
• Poor citation grounding
• Lack of modularity
• Limited explainability

This project addresses these limitations by designing a multi-agent architecture where each agent has a clearly defined responsibility and interacts through an orchestrated workflow.

3. System Architecture Overview

The system is built as a LangGraph state machine, where agents operate on a shared structured state.

Technology Stack

4. Multi-Agent Design

The system consists of four specialized agents:

4.1 Planner Agent

Purpose:
Transforms the user topic into a structured research outline.

Responsibilities:

• Break down topic into logical sections
• Generate research questions for each section
• Produce structured JSON output

This ensures the research process is guided by a predefined analytical structure.

4.2 Research Agent

Purpose:
Collects and stores relevant external information.

Responsibilities:

• Perform DuckDuckGo search per section
• Retrieve source URLs
• Extract webpage content
• Chunk text into semantic segments
• Generate embeddings
• Store chunks in ChromaDB with metadata

Metadata stored:

• Section name
• Source URL
• Chunk ID

This establishes the Retrieval-Augmented Generation (RAG) pipeline.

4.3 Verifier Agent

Purpose:
Ensures evidence coverage and relevance.

Responsibilities:

• Retrieve relevant chunks via similarity search
• Evaluate whether research questions are supported
• Flag insufficient coverage
• Confirm readiness for synthesis
• Compute coverage score
• Evaluate source diversity
• Apply trust scoring

This step reduces unsupported claims and improves report reliability.

4.4 Writer Agent

Purpose:
Generates the final structured research report.

Responsibilities:

• Retrieve top-k relevant chunks
• Synthesize findings per section
• Attach citations
• Generate structured Markdown output
• Generate PDF

The final report includes:

• Section headings
• Structured analysis
• Source references

5. Orchestration with LangGraph

The system uses a shared state object:

class ResearchState(TypedDict):
    topic: str
    outline: dict
    research_complete: bool
    verified: bool
    report: str

Workflow

START
  ↓
Planner Agent
  ↓
Research Agent
  ↓
Verifier Agent
  ↓
Writer Agent
  ↓
END

Each agent updates the shared state, enabling controlled transitions between stages.
This design ensures:

• Clear separation of concerns
• Traceable reasoning flow
• Modular debugging
• Expandability

Flow Diagram

The workflow pipeline is visualized as:

User Topic
    ↓
Planner Agent
    ↓
Researcher Agent
    ↓
Verifier Agent
    ↓
Writer Agent
    ↓
Structured Report (MD/PDF)

6. Tool Integration

The system integrates multiple external tools:

6.1. DuckDuckGo Search Tool

Provides free web search capability for retrieving research sources.

6.2. Web Content Extraction Tool

Uses requests and BeautifulSoup to extract readable text from webpages.

6.3. Embedding Model

sentence-transformers/all-MiniLM-L6-v2 generates semantic embeddings for chunked text.

6.4. ChromaDB Vector Store

Stores embeddings and metadata for similarity-based retrieval.

6.5. Markdown Report Formatter

Formats structured output into publishable research documentation.

6.6. ReportLab PDF Exporter

Generates PDF versions of reports.

This satisfies the requirement of integrating multiple tools within a coordinated multi-agent system.

7. Execution Flow

1. User provides a research topic via API or UI.
2. Planner generates a structured outline.
3. The research agent performs a web search and builds a vector knowledge base.
4. Verifier checks coverage and retrieval quality.
5. Writer synthesizes final evidence-backed report.
6. Final report is exported in Markdown and PDF formats.

8. Screenshots & User Interface

The system provides an interactive Streamlit frontend for easy usage, alongside the FastAPI backend. Below are key screenshots demonstrating the user experience and output quality.

8.1 Streamlit Frontend – Input Screen

• Topic entry field
• "Generate Report" button

8.2 Final Report Output (Markdown View)

• Structured sections with headings
• Inline citations
• Clean, readable formatting

8.3 PDF Export Preview

• Professional layout generated via ReportLab
• Preserves citations and formatting

These screenshots showcase the end-to-end user journey from topic input to fully cited, exportable research report.

9. Repository Structure

.
├── backend/
│   ├── app/
│   │   ├── agents/               # Agent logic
│   │   ├── api/                  # FastAPI routes
│   │   ├── config/               # Settings & env handling
│   │   ├── core/                 # Shared utilities
│   │   ├── data/
│   │   │   ├── chroma/           # ChromaDB persistence
│   │   │   └── state/            # JSON state snapshots per report
│   │   ├── graph/                # LangGraph workflow definition
│   │   ├── schemas/              # Pydantic models
│   │   ├── tools/                # Search, loader, embedding tools
│   │   ├── outputs/              # ← Generated Markdown + PDF reports go here
│   │   └── main.py               # FastAPI entry point
│   └── tests/                    # Tests
├── frontend/
│   └── app.py                    # Streamlit UI
├── sample-scr/                   # Sample screenshots / example outputs
├── .env_example
├── .gitignore
├── LICENSE
├── README.md
└── requirements.txt

This modular structure reflects the agent-tool separation principle.

10. Key Design Decisions

10.1. Explicit Role Separation

Each agent performs one clearly defined responsibility.

10.2. Local Embeddings + Vector Store

Ensures cost-efficiency and reproducibility.

10.3. Free Web Search Integration

Avoids API dependency barriers.

10.4. State-Based Orchestration

LangGraph enables deterministic and extensible workflow control.

10.5. Multi-LLM Support

Supports OpenAI, Groq, and Google Gemini for flexibility.

10.6. API and UI Integration

FastAPI for backend services and Streamlit for user-friendly interface.

11. Results

The system successfully generates:

• Structured research reports
• Citation-backed analysis
• Modular execution traces
• Expandable architecture for future improvements

The design demonstrates how multi-agent orchestration improves reasoning clarity and reduces hallucination risks compared to single-agent pipelines.

12. Configuration and Tuning

LLM Priority Order

1. OpenAI
2. Groq
3. Google Gemini

Override models:

OPENAI_MODEL=gpt-4o-mini
GROQ_MODEL=llama-3.1-8b-instant
GOOGLE_MODEL=gemini-2.0-flash

Search & Retrieval

Verification

Storage

Performance Tuning

• Optimize for Speed: Reduce MAX_SEARCH_RESULTS, CHUNK_SIZE, TOP_K_EVIDENCE.
• Optimize for Quality: Increase MAX_SEARCH_RESULTS, CHUNK_SIZE, TOP_K_EVIDENCE, COVERAGE_THRESHOLD.
• Optimize for Cost: Use Groq or Google models.

13. API Reference

Base URL: http://localhost:8000

Generate Research Report

POST /generate-report

Request:

{  
  "topic": "Applications of artificial intelligence in healthcare"  
}  

Response:

{  
  "topic": "...",  
  "report": "...",  
  "citations": [],  
  "coverage_score": 0.85,  
  "verified": true,  
  "report_id": "uuid",  
  "outputs": {  
    "markdown": "...",  
    "pdf": "..."  
  },  
  "research_status": {  
    "planning": "completed",  
    "research": "completed",  
    "verification": "completed",  
    "writing": "completed"  
  }  
}  

Report History

GET /history
Returns list of all reports.

Retrieve Specific Report

GET /history/{name}
Returns markdown content and PDF path.

Health Check

GET /health

{ "status": "ok" }  

14. State Management

State snapshots saved at:
backend/app/data/state/

Files:
{report_id}_planner.json
{report_id}_researcher.json
{report_id}_verifier.json
{report_id}_writer.json

15. Report Output

Generated reports stored in:
backend/app/outputs/

Formats:

• Markdown (.md)
• PDF (.pdf)

16. Testing

Run tests:

pytest backend/tests/  
pytest backend/tests/ --cov=backend/app  

17. Security Considerations

• Never commit .env
• Use HTTPS in production
• Implement authentication
• Enable rate limiting
• Rotate API keys
• Log API access
• Use secrets manager
• Backup state & outputs

18. Docker Deployment

Dockerfile:

FROM python:3.11-slim  
WORKDIR /app  
COPY requirements.txt .  
RUN pip install --no-cache-dir -r requirements.txt  
COPY backend ./backend  
COPY frontend ./frontend  
EXPOSE 8000 8501  
CMD ["sh", "-c", "python -m uvicorn backend.app.main:app --host 0.0.0.0 --port 8000 & python -m streamlit run frontend/app.py --server.port 8501 --server.address 0.0.0.0"]  

Build and run:

docker build -t research-generator .  
docker run -p 8000:8000 -p 8501:8501 -e OPENAI_API_KEY=your_key research-generator  

19. Troubleshooting

No API Key

Ensure at least one provider key is set.

Port in Use

Use different port with --port.

ChromaDB Issues

Clear:

rm -rf backend/app/data/chroma  

Frontend Cannot Connect

Check:

curl http://localhost:8000/health  

20. Future Improvements / Roadmap

• Iterative verification loops
• Source credibility scoring
• Parallelized research per section
• Web UI interface enhancements
• Async search optimization
• Credibility weighting algorithms
• Streaming responses
• Batch reports
• Academic DB integration
• Agent pipeline builder
• Version comparison
• Multi-language support

21. Conclusion

This project demonstrates how a properly designed multi-agent architecture can enhance reliability, modularity, and explainability in research report generation.
By combining:

• LangGraph orchestration
• Tool-integrated RAG
• Explicit agent role separation
• API and UI layers
• Multi-LLM support

The system moves beyond a simple LLM pipeline and becomes a structured, extensible research automation framework.

GitHub Repository:
https://github.com/Raghul-S-Coder/Multi-Agent-Research-Evidence-Based-Report-Generator

Author:
Raghul S
GitHub: https://github.com/Raghul-S-Coder

Version: 0.1.0
Last Updated: February 2026