Autonomous Multi-Agent Research & Action System (AMRAS)

An intelligent system where multiple AI agents collaborate to solve complex research tasks, retrieve enterprise data, and execute real-world actions. Built with a modern 2026 tech stack.

---

Architecture

User Query → [Researcher Agent] → [Critic Agent] ←→ (loop if revision needed)
                                        ↓
                                  [Writer Agent] → Final Report / Email

Multi-Agent Workflow

Agent	Role	Tools	Temperature
Researcher	Gathers information from documents & web	Document Search (RAG), Web Search	0.3
Critic	Reviews for accuracy & hallucinations	Document Search, Web Search, Fact Check	0.2
Writer	Produces polished final output	Email Draft	0.7

The Critic agent can send research back for revision, creating a self-improving loop (up to N iterations).

---

Tech Stack

Layer	Technology	Purpose
AI Orchestration	LangGraph	Cyclic multi-agent workflows
LLM Providers	Ollama, OpenAI, Google Gemini	Flexible model selection
Vector Database	Qdrant	Document embeddings for RAG
Embeddings	Sentence Transformers (all-MiniLM-L6-v2)	Text → vector encoding
Backend	Django + DRF	REST API, ORM, admin
Frontend	Django Templates + Tailwind CSS	Modern dark UI
Task Queue	Celery + Redis	Async processing
Deployment	Docker + Docker Compose	Container orchestration

---

Features

• Document RAG Pipeline: Upload PDFs, DOCX, TXT, MD, CSV → chunk → embed → store in Qdrant → semantic search
• Multi-Agent Collaboration: Researcher → Critic → Writer with iterative refinement
• Tool Use: Agents can search documents, search the web, fact-check claims, and draft emails
• Multiple LLM Support: Switch between Ollama (local/free), OpenAI, and Google Gemini
• Modern UI: Dark-themed Django UI with real-time agent activity tracking
• REST API: Full CRUD API via Django REST Framework
• Docker Ready: One-command deployment with Docker Compose

---

Quick Start

Prerequisites

• Python 3.12+
• Docker & Docker Compose (for Qdrant)
• Ollama (for local LLMs) — optional if using OpenAI/Gemini

1. Clone & Setup

git clone https://github.com/yourusername/Autonomous-Multi-Agent-Research-Action-System.git
cd Autonomous-Multi-Agent-Research-Action-System

# Create virtual environment
python -m venv venv
source venv/bin/activate  # or `venv\Scripts\activate` on Windows

# Install dependencies
pip install -r requirements.txt

2. Environment Configuration

cp .env.example .env
# Edit .env with your API keys

3. Start Infrastructure

# Start Qdrant vector database
docker run -d -p 6333:6333 -p 6334:6334 qdrant/qdrant

# (Optional) Start Ollama and pull a model
ollama pull llama3

4. Initialize Django

python manage.py migrate
python manage.py seed_agents
python manage.py createsuperuser
python manage.py runserver

5. Open the App

• Dashboard: http://localhost:8000/
• Research Chat: http://localhost:8000/chat/
• Documents: http://localhost:8000/documents/
• Admin: http://localhost:8000/admin/
• API Root: http://localhost:8000/api/

---

Docker Deployment

# Full stack with one command
docker-compose up -d

# This starts:
# - Django web app (port 8000)
# - Qdrant vector DB (port 6333)
# - Redis (port 6379)
# - Celery worker
# - Ollama (port 11434)

---

API Endpoints

Method	Endpoint	Description
GET	/api/documents/	List all documents
POST	/api/documents/upload/	Upload & process a document
POST	/api/documents/search/	Semantic search across documents
GET	/api/sessions/	List chat sessions
POST	/api/sessions/{id}/query/	Send query to multi-agent system
GET	/api/sessions/{id}/messages/	Get session messages
GET	/api/agents/	List agent configurations
GET	/api/agent-runs/	Agent execution history
GET	/api/llm-providers/	Available LLM providers
GET	/api/emails/	Drafted emails
POST	/api/emails/{id}/send/	Send a drafted email

---

Project Structure

├── config/                    # Django project settings
│   ├── settings.py
│   ├── urls.py
│   ├── celery.py
│   └── asgi.py
├── apps/
│   ├── documents/             # Document upload & management
│   ├── agents/                # Agent configuration & runs
│   ├── chat/                  # Chat sessions & UI views
│   └── tools/                 # Tool executions & email drafts
├── services/
│   ├── vector_db.py           # Qdrant vector database service
│   ├── document_processor.py  # Document loading & chunking
│   ├── llm_service.py         # LLM provider factory
│   ├── multi_agent.py         # LangGraph multi-agent workflow
│   └── agent_tools.py         # LangChain tools for agents
├── templates/                 # Django UI templates
│   ├── base.html
│   ├── dashboard.html
│   ├── chat.html
│   ├── documents.html
│   ├── agents.html
│   └── emails.html
├── Dockerfile
├── docker-compose.yml
├── requirements.txt
└── manage.py

---

How It Works

Phase 1: Document Ingestion (RAG)

1. Upload a document (PDF, DOCX, etc.)
2. Text is extracted and split into overlapping chunks
3. Each chunk is embedded using Sentence Transformers
4. Embeddings are stored in Qdrant vector database

Phase 2: Multi-Agent Research

1. User submits a research query
2. Researcher Agent searches documents (RAG) and the web
3. Critic Agent reviews the research for accuracy and completeness
4. If issues found → loops back to Researcher (up to N iterations)
5. Writer Agent produces a polished, formatted response

Phase 3: Action & Output

• Writer can draft emails with research findings
• Results include citations from documents and web sources
• Full agent activity log visible in the UI

---

Configuration

LLM Providers

Provider	Setup	Best For
Ollama	ollama pull llama3	Free, local, data privacy
OpenAI	Set OPENAI_API_KEY in .env	Best quality (GPT-4o)
Google	Set GOOGLE_API_KEY in .env	Fast & affordable (Gemini)

Environment Variables

See .env.example for all configuration options.

---

License

MIT