Praval Deep Research

A Local-First, AI-Powered Research Assistant for ArXiv Papers

Built with the Praval Agentic Framework - demonstrating production-grade, identity-driven agent architecture for intelligent research workflows.

🎯 What Is This?

Praval Deep Research is a local-first, privacy-focused research assistant that helps you discover, analyze, and understand academic papers from ArXiv. All your research data stays on your machine - papers, embeddings, conversations, and insights are stored locally. Supports multiple LLM providers including OpenAI, Anthropic (Claude), and Ollama for fully local operation.

Discover page: Search ArXiv, select papers, and index to your knowledge base

Core Philosophy

Local-First Architecture

All data stored on your infrastructure (PostgreSQL, Qdrant, MinIO, Redis)
Papers and embeddings remain on your machine
Complete control over your research knowledge base
External API calls only for ArXiv paper downloads and OpenAI LLM/embeddings
Ollama support for fully offline operation with local models

Agent-Driven Intelligence

Built on Praval - the modern agentic framework
6 specialized agents with memory and learning capabilities
Identity-driven design: agents ARE specialists, not just function executors
Self-organizing workflow through message passing (spores)

ArXiv-Focused

Current build optimized for ArXiv paper research
Semantic search across downloaded papers
Intelligent Q&A using vector embeddings
Knowledge base management for your research corpus

✨ Key Features

📚 Paper Discovery & Management

Smart Search: Query ArXiv with domain-specific filtering
Automatic Processing: Downloads PDFs, extracts text, generates embeddings
Knowledge Base: View all indexed papers with statistics and metadata
PDF Viewing: Open and read papers directly in your browser
Easy Management: Delete individual papers or clear entire knowledge base

💬 Intelligent Conversations

Research Chat: Ask questions about your papers with source citations

Generate Content: Create Twitter threads or blog posts from your research

Chat History: All conversations automatically saved with PostgreSQL (persistent relational storage)
Smart Titles: LLM-generated conversation names (like ChatGPT/Claude)
Conversation Management: Create, load, and delete chat threads with cascade integrity
Context-Aware Answers: LLM generates answers using retrieved evidence
Source Citations: Every answer cites specific papers with relevance scores
Follow-up Suggestions: Get 3 related questions to explore deeper
Copy with Citations: Easy sharing of assistant responses with full source attribution

📖 Knowledge Base Management

Knowledge Base: 134 papers indexed with search, filters, and sorting

Find Related Papers: Extract citations and discover related ArXiv papers

Paper Catalog: Sortable table of all indexed papers
Statistics Dashboard: Real-time metrics on papers, vectors, and categories
PDF Access: View any indexed paper with one click
Search & Filter: Find specific papers in your collection
Bulk Operations: Clear entire knowledge base when needed
Find Related Papers: Extract citations from any paper and discover related ArXiv papers
Summarize in Chat: One-click workflow to summarize any paper in a dedicated conversation

🔗 Citation Discovery (NEW)

Find Related Papers: Click "Related" on any paper to extract its citations
LLM-Powered Extraction: Uses GPT-4o-mini to identify citations from PDF references section
ArXiv Search: Automatically searches ArXiv for cited papers
Smart Indexing: Select which related papers to add to your knowledge base
Already Indexed Detection: Shows which cited papers are already in your KB

🤖 Praval Agent Architecture

Six specialized agents working autonomously:

Paper Discovery Agent - Searches and ranks ArXiv papers with memory-driven optimization
Document Processor Agent - Downloads, extracts, chunks, and generates embeddings
Semantic Analyzer Agent - Identifies themes and connections across papers
Summarization Agent - Creates comprehensive paper syntheses
Q&A Specialist Agent - Answers questions using retrieved context and personalization
Research Advisor Agent - Provides strategic research guidance

Each agent has:

Memory: Learns from interactions and improves over time
Identity: Clear specialization and domain expertise
Intelligence: LLM-powered decision making
Autonomy: Self-organizing through message passing

🎨 Modern User Experience

React + TypeScript: Type-safe, component-based frontend
Tailwind CSS: Clean, accessible design with proper color contrast
Responsive Design: Works on desktop and tablet
Real-time Updates: Live progress tracking during indexing
Keyboard Shortcuts: Efficient navigation and interaction
Dark Mode Ready: Infrastructure for theme switching

🔍 Vajra BM25 Hybrid Search (NEW)

Knowledge Base Search: Hybrid search with adjustable keyword/semantic balance

Dual Search Modes: Toggle between ArXiv (external) and Knowledge Base (indexed papers)
Hybrid Search Engine: Powered by Vajra BM25 with RRF fusion
Adjustable Search Balance: Slider to control keyword↔semantic weighting
- α=1.0: Pure BM25 keyword search (exact term matching)
- α=0.5: Balanced hybrid (default, best of both worlds)
- α=0.0: Pure semantic/vector search (conceptual similarity)
Paper Selection: Select multiple papers from search results
Chat with Papers: Start contextual Q&A focused on selected papers
Server-side Filtering: Responses filtered to selected papers at the database level

🔮 Proactive Research Insights (NEW)

Research Insights: AI-identified research areas with related papers and quick actions

Interactive Topic Discovery: Click trending topics to instantly search and view papers
Research Area Clustering: AI-powered identification of your research themes
Trending Topics: Automatically extracted from your indexed papers
Research Gaps: AI suggests unexplored areas and opportunities
Personalized Next Steps: Strategic research recommendations based on chat history
Smart Caching: Insights generated in 35s, cached for instant retrieval (1hr TTL)
Context-Aware: Analyzes both knowledge base and recent conversation patterns
Fast Category Filter: Category clicks use Vajra BM25 index (~3ms response)

⚙️ Settings & Configuration

In-App Settings Page: Configure all options from the UI
Multi-Provider Support: Switch between OpenAI, Anthropic, or Ollama
API Key Management: Securely store keys locally (never sent to external servers)
Ollama Auto-Detection: Automatically discovers installed local models
Model Selection: Choose your preferred model per provider
LangExtract Configuration: Separate provider selection for PDF extraction

🏗️ Production-Grade Infrastructure

Vector Database: Qdrant for semantic search (1536-dim OpenAI embeddings)
Persistent Storage: PostgreSQL for chat conversation history with relational integrity
Performance Cache: Redis for research insights caching (1-hour TTL, 35s→instant)
Object Storage: MinIO for PDF storage with streaming proxy
Message Queue: RabbitMQ for reliable agent communication
Real-time Updates: Server-Sent Events for live progress tracking
Containerized: Full Docker Compose deployment with health checks
Desktop App: Native Tauri app for macOS, Windows, and Linux
Monitoring: Structured logging with JSON output

🚀 Quick Start

Prerequisites

Docker & Docker Compose (required)
OpenAI API Key (for embeddings and LLM)
8GB+ RAM (recommended)
10GB+ Disk Space (for papers and vectors)

1. Clone and Configure

git clone https://github.com/aiexplorations/praval_deep_research.git
cd praval_deep_research

# Copy environment template
cp .env.example .env

# Edit and add your OpenAI API key
nano .env
# Set: OPENAI_API_KEY=sk-your-key-here

2. Deploy (One Command)

# Build and start all services
docker-compose up -d

# Check status
docker-compose ps

# View logs
docker-compose logs -f research_frontend research_api

3. Access Your Research Assistant

Frontend: http://localhost:3000
API Documentation: http://localhost:8000/docs
RabbitMQ Management: http://localhost:15672 (user: research_user, pass: research_pass)
MinIO Console: http://localhost:9001 (user: minioadmin, pass: minioadmin)

🖥️ Desktop App (Tauri)

Praval Deep Research can also run as a native desktop application using Tauri, providing a lightweight, secure, and fast experience without requiring Docker.

Download Pre-built Release ⚡

The fastest way to get started - no build dependencies required!

Download from GitHub Releases:

Platform	Download
macOS (Apple Silicon)	`Praval-Deep-Research_*_aarch64.dmg`
macOS (Intel)	`Praval-Deep-Research_*_x64.dmg`
Windows	`Praval-Deep-Research_*_x64-setup.exe` or `.msi`
Linux	`praval-deep-research_*.AppImage` or `.deb`

Simply download, install, and run - no Python or other dependencies needed!

Build From Source

If you want to build from source (for development or customization):

macOS:

git clone https://github.com/aiexplorations/praval_deep_research.git
cd praval_deep_research
./scripts/install-macos.sh

Windows (PowerShell as Administrator):

git clone https://github.com/aiexplorations/praval_deep_research.git
cd praval_deep_research
.\scripts\install-windows.ps1

Linux (Ubuntu/Debian/Fedora/Arch):

git clone https://github.com/aiexplorations/praval_deep_research.git
cd praval_deep_research
./scripts/install-linux.sh

The install scripts will:

✅ Check and install all required dependencies (Node.js, Rust, Python)
✅ Install platform-specific build tools
✅ Optionally install Ollama for free local LLM support
✅ Build the Python backend binary
✅ Build the desktop application
✅ Provide the installer/app package

Manual Build (Advanced)

If you prefer to install dependencies manually:

Prerequisites

Node.js 18+ and npm
Rust (install via rustup.rs)
Python 3.11+ with pip
Platform-specific dependencies:
- macOS: Xcode Command Line Tools (xcode-select --install)
- Windows: Visual Studio Build Tools with C++ workload
- Linux: sudo apt install libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf

Build Steps

# 1. Install Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source ~/.cargo/env

# 2. Set up Python
python3 -m venv venv
source venv/bin/activate  # Windows: venv\Scripts\activate
pip install -r requirements.txt

# 3. Install frontend dependencies
cd frontend-new && npm install && cd ..

# 4. Build desktop app
cd desktop
npm install
npm run tauri build  # or: npm run tauri dev (for development)

Build Output Locations

macOS: desktop/src-tauri/target/release/bundle/dmg/Praval Deep Research_*.dmg
Windows: desktop/src-tauri/target/release/bundle/msi/Praval Deep Research_*.msi
Linux: desktop/src-tauri/target/release/bundle/appimage/praval-deep-research_*.AppImage

Desktop App Configuration

The desktop app stores configuration locally:

macOS: ~/Library/Application Support/Praval/config.json
Windows: %APPDATA%/Praval/config.json
Linux: ~/.config/praval/config.json

On first launch, go to Settings to configure your LLM provider and API keys.

Using Ollama (Free Local Models)

For fully offline operation with no API costs:

# 1. Install Ollama from https://ollama.ai
# macOS:
brew install ollama

# 2. Start Ollama service
ollama serve

# 3. Pull a model (e.g., llama3.2, mistral, or codellama)
ollama pull llama3.2

# 4. In Praval Settings, select "Ollama" as your LLM provider
# The app will auto-detect your installed models

Recommended Ollama Models:

llama3.2 - Great general-purpose model (3B/8B parameters)
mistral - Fast and capable (7B parameters)
mixtral - High quality responses (8x7B MoE)
codellama - Best for code-related research
gemma2:9b - Google's efficient model

📖 How It Works

Research Workflow

graph LR
    A[Search ArXiv] --> B[Paper Discovery Agent]
    B --> C[Download PDFs]
    C --> D[Document Processor Agent]
    D --> E[Extract & Chunk Text]
    E --> F[Generate Embeddings]
    F --> G[Store in Qdrant]
    G --> H[Ready for Q&A]
    H --> I[Q&A Specialist Agent]
    I --> J[Answer Questions]
    J --> K[Save to PostgreSQL]

Example Usage

1. Discover Papers

Navigate to the Discover page
Search: "transformer attention mechanisms"
Select papers and click "Index Selected"
Watch real-time processing updates

2. Papers Are Automatically Processed

PDFs downloaded to local MinIO storage
Text extracted and chunked intelligently (1000 chars, 200 overlap)
Embeddings generated with OpenAI text-embedding-3-small
Vectors stored in local Qdrant database
~30-60 seconds per paper

3. Ask Questions in Chat

Navigate to the Chat page
Ask: "What are the key innovations in transformer architecture?"
Receive answer with source citations
Conversation auto-saves with smart title (generated by LLM)
Access chat history from sidebar
Copy answers with citations for easy sharing

4. Explore Proactive Research Insights

View AI-generated research insights at bottom of Discover page
See your research areas, trending topics, and identified gaps
Click any trending topic to instantly search and view papers
Get personalized next steps based on your research patterns

5. Manage Your Knowledge Base

Navigate to Knowledge Base page
View all 28 indexed papers
See 1,641 stored vectors
Average 58.6 chunks per paper
Click "View PDF" to read any paper
Delete papers or clear entire knowledge base

🏛️ Architecture

System Overview

┌─────────────────────────────────────────────┐
│   React Frontend (TypeScript + Vite)       │
│              Port 3000                      │
└────────────────┬────────────────────────────┘
                 │ HTTP/REST
                 ↓
┌─────────────────────────────────────────────┐
│      FastAPI Backend (REST + SSE)           │
│              Port 8000                      │
└─┬──┬──┬──┬──┬─────────────────────┬─────────┘
  │  │  │  │  │                     │
  │  │  │  │  │                     ↓
  │  │  │  │  │              ┌─────────────┐
  │  │  │  │  │              │  RabbitMQ   │
  │  │  │  │  │              │   Queue     │
  │  │  │  │  │              └──────┬──────┘
  │  │  │  │  │                     │
  │  │  │  │  │                     ↓
  │  │  │  │  │              ┌─────────────┐
  │  │  │  │  │              │   Praval    │
  │  │  │  │  │              │   Agents    │
  │  │  │  │  │              │ 6 Specialists│
  │  │  │  │  │              └──┬──┬───┬───┘
  │  │  │  │  │                 │  │   │
  ↓  ↓  ↓  ↓  ↓                 ↓  ↓   ↓
┌───┐┌────┐┌──────┐┌──────┐  ┌────────────┐
│PG ││Redis│Qdrant││MinIO │  │  OpenAI    │
│   ││     │Vector││ PDFs │  │ Embeddings │
│   ││Cache││  DB  ││      │  │    LLM     │
└───┘└────┘└──────┘└──────┘  └────────────┘
 Chat  Insights  Papers   Storage     AI
History  (1hr)  Vectors   Objects   Services

Data Flow:

User Request → Frontend makes HTTP request to Backend API
Backend Processing → API coordinates with storage (PostgreSQL, Redis, Qdrant, MinIO)
Agent Tasks → Backend publishes heavy processing tasks to RabbitMQ
Agent Execution → Praval agents consume tasks, process data, access storage and OpenAI
Response Delivery → Results flow back through RabbitMQ or direct API response to Frontend

Storage Strategy:

PostgreSQL: Durable relational data (conversations, messages) with ACID guarantees
Redis: High-performance cache (research insights) with TTL expiration
Qdrant: Semantic search vectors for intelligent paper retrieval
MinIO: Large binary objects (PDF files) with S3-compatible API

New Features in Latest Version

Storage Architecture Enhancements

PostgreSQL: Persistent relational storage for chat conversations and messages
Redis: High-performance caching for research insights (1hr TTL)
Hybrid strategy: Durable data in PostgreSQL, performance cache in Redis
CASCADE delete integrity for conversations and messages
SQLAlchemy async ORM with connection pooling

Proactive Research Insights

AI-powered research area identification from indexed papers
Trending topic extraction with clickable search
Research gap discovery and opportunity suggestions
Personalized next steps based on chat history
Interactive insights: click topics to instantly search papers
Smart caching: 35s generation → instant retrieval

Chat History & Conversations

Persistent conversation storage in PostgreSQL with relational integrity
Auto-generated titles using GPT-4o-mini
Conversation list with message counts and timestamps
Delete conversations with CASCADE to remove all messages
Auto-load most recent conversation
Copy answers with citations for easy sharing

Frontend Enhancements

Multi-stage Docker build (Node.js → Nginx)
Production-optimized React bundle with code splitting
Improved chat layout with full-height display
One-click topic search from insights panel
PDF streaming through API proxy
Opens in new tab for reading
Inline display in browser

UX Improvements

Improved color palette with WCAG AA contrast
Removed annoying confirmation dialogs
Hover-activated delete buttons
Modern rounded UI elements
Praval branding in header

🔧 Configuration

Environment Variables

# Required
OPENAI_API_KEY=sk-your-key-here

# Optional (sensible defaults provided)
CHUNK_SIZE=1000                    # Text chunk size
CHUNK_OVERLAP=200                  # Overlap between chunks
MAX_CHUNKS_PER_PAPER=50           # Limit chunks per paper
EMBEDDING_DIMENSIONS=1536          # OpenAI embedding size
QDRANT_COLLECTION_NAME=research_vectors

# MinIO Configuration
MINIO_ENDPOINT=minio:9000              # Internal endpoint
MINIO_EXTERNAL_ENDPOINT=localhost:9000 # Browser-accessible endpoint

Storage Locations

All data stored locally in Docker volumes:

Papers (PDFs): minio_data volume (~1-5GB per 100 papers)
Vectors: qdrant_data volume (~200MB per 1000 chunks)
Messages: rabbitmq_data volume
Conversations: redis_data volume
Frontend: Served from Nginx container

To backup data:

# Backup volumes
docker run --rm -v praval_deep_research_qdrant_data:/data -v $(pwd):/backup \
  alpine tar czf /backup/qdrant_backup.tar.gz /data

# Restore
docker run --rm -v praval_deep_research_qdrant_data:/data -v $(pwd):/backup \
  alpine tar xzf /backup/qdrant_backup.tar.gz -C /

📊 Monitoring & Management

View Services Status

docker-compose ps

# Expected output:
# research_api        Up (healthy)
# research_frontend   Up (healthy)
# research_qdrant     Up
# research_minio      Up (healthy)
# research_rabbitmq   Up (healthy)
# research_redis      Up (healthy)

View Logs

# Frontend logs
docker-compose logs -f research_frontend

# API logs
docker-compose logs -f research_api

# All services
docker-compose logs -f

Knowledge Base API

# Get stats
curl http://localhost:8000/research/knowledge-base/stats | jq

# List all papers
curl http://localhost:8000/research/knowledge-base/papers | jq

# Get specific paper PDF
curl http://localhost:8000/research/knowledge-base/papers/2504.13908v2/pdf > paper.pdf

Conversation Management

# List all conversations
curl http://localhost:8000/research/conversations | jq

# Get specific conversation with messages
curl http://localhost:8000/research/conversations/{conversation_id} | jq

🧪 Development

Local Development (With Docker for services)

# Start infrastructure only
docker-compose up -d rabbitmq qdrant minio redis

# Frontend development (with hot reload)
cd frontend-new
npm install
npm run dev
# Opens on http://localhost:3001

# Backend development (separate terminal)
cd src
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
python -m uvicorn agentic_research.api.main:app --reload --port 8000

Building for Production

# Build all containers
docker-compose build

# Build specific service
docker-compose build research_frontend

# Check image sizes
docker images | grep praval_deep_research

Testing

# Test paper search
curl -X POST http://localhost:8000/research/search \
  -H "Content-Type: application/json" \
  -d '{"query": "neural networks", "max_results": 3}'

# Test Q&A
curl -X POST http://localhost:8000/research/ask \
  -H "Content-Type: application/json" \
  -d '{"question": "What are transformers?", "include_sources": true}'

# Test conversation creation
curl -X POST http://localhost:8000/research/conversations \
  -H "Content-Type: application/json" \
  -d '{"title": "My Research Chat"}'

🌟 Built with Praval

This project showcases the power of the Praval Agentic Framework:

Why Praval?

Identity-Driven Agents

Agents are defined by what they ARE, not just what they DO
Clear specialization leads to better performance
Natural language identity statements guide behavior

Memory & Learning

Agents remember past interactions using remember() and recall()
Continuous improvement through experience
Context-aware decision making with historical patterns

Self-Organizing

No central coordinator needed
Agents communicate via message passing (spores)
Emergent intelligence from simple interactions

Production-Ready

Type-safe, well-tested framework
Enterprise-grade reliability
Scales horizontally with Docker

Learn More About Praval

Website: pravalagents.com
Documentation: Comprehensive guides and examples
Philosophy: Identity-driven, memory-enabled, LLM-integrated agents

🗺️ Roadmap

Current (v1.2)

✅ ArXiv paper search and indexing
✅ Semantic Q&A over indexed papers
✅ Knowledge base management with PDF viewing
✅ Chat history with persistent conversations
✅ Auto-generated conversation titles
✅ Modern React + TypeScript frontend
✅ Full Docker containerization
✅ 6 specialized Praval agents with memory
✅ Find Related Papers: Citation extraction and ArXiv discovery
✅ Summarize in Chat: One-click paper summaries
✅ Proactive Research Insights with clickable topics
✅ Advanced KB filters (search, category, source, sort)
✅ Vajra BM25 Hybrid Search: Keyword + semantic with RRF fusion
✅ Chat with Papers: Select papers and start focused Q&A
✅ Adjustable Search Balance: Slider for keyword↔semantic weighting
✅ Fast Category Filter: ~3ms response using Vajra BM25 index

In Progress

🔄 Voice interface for hands-free research
🔄 Export conversations and research notes

Planned

📋 Support for more paper sources (PubMed, IEEE, etc.)
📋 Intelligent knowledge base curation agent
📋 Paper recommendation system
📋 Research workflow automation
📋 Citation graph analysis
📋 Multi-user support with authentication
📋 Custom embedding models
✅ Ollama integration for offline LLM support
✅ Desktop app with Tauri for native experience
✅ Settings page for in-app configuration

🐛 Troubleshooting

Services Won't Start

# Check Docker is running
docker ps

# Check for port conflicts
lsof -i :3000  # Frontend
lsof -i :8000  # API
lsof -i :9000  # MinIO

# Restart all services
docker-compose down
docker-compose up -d

# Check logs for errors
docker-compose logs research_api

Frontend Shows Blank Page

# Hard refresh browser
# Chrome/Edge: Ctrl+Shift+R (Windows) or Cmd+Shift+R (Mac)
# Firefox: Ctrl+F5 or Cmd+Shift+R

# Check if frontend container is running
docker-compose ps research_frontend

# Check nginx logs
docker-compose logs research_frontend

Q&A Returns No Results

# Check if papers are indexed
curl http://localhost:8000/research/knowledge-base/stats

# Verify Qdrant has vectors
curl http://localhost:6333/collections/research_vectors

# Check Qdrant logs
docker-compose logs research_qdrant

Chat History Not Saving

# Check Redis is running
docker-compose ps research_redis

# Test Redis connection
docker-compose exec research_redis redis-cli ping
# Should return: PONG

# Check conversation API
curl http://localhost:8000/research/conversations

PDF Viewing Not Working

# Check MinIO is accessible
curl http://localhost:9000/minio/health/live

# Test PDF endpoint directly
curl -I http://localhost:8000/research/knowledge-base/papers/{paper_id}/pdf

# Check MinIO logs
docker-compose logs research_minio

📚 Documentation

User Manual - Comprehensive guide for using Praval Deep Research
User Manual PDF - Printable version
Design Document - System architecture and design decisions
Project Guidelines - Development standards and best practices

📄 License

MIT License - see LICENSE file for details.

🙏 Acknowledgments

Praval Framework - The foundation of this agentic system
Vajra BM25 - High-performance hybrid search engine
ArXiv - Open access to research papers
Qdrant - High-performance vector database
FastAPI - Modern Python web framework
React - UI component library
OpenAI - Embeddings and language models
Tailwind CSS - Utility-first CSS framework

📞 Support

User Manual: See USER_MANUAL.md for detailed usage guide
Issues: GitHub Issues for bug reports and feature requests
Praval Framework: pravalagents.com for framework documentation
Community: Discussions and questions welcome in GitHub Discussions

Built with ❤️ using Praval - Demonstrating production-grade agentic architecture for research automation.

Praval Framework | Documentation | Issues

Name		Name	Last commit message	Last commit date
Latest commit History 39 Commits
.github/workflows		.github/workflows
desktop		desktop
docker		docker
frontend-new		frontend-new
frontend		frontend
img		img
plans		plans
scripts		scripts
src		src
tests		tests
.env.example		.env.example
.gitignore		.gitignore
.pre-commit-config.yaml		.pre-commit-config.yaml
CLAUDE.md		CLAUDE.md
DESIGN.md		DESIGN.md
DEVELOPMENT.md		DEVELOPMENT.md
README.md		README.md
STORAGE_ENHANCEMENT_TEST_RESULTS.md		STORAGE_ENHANCEMENT_TEST_RESULTS.md
USER_MANUAL.md		USER_MANUAL.md
USER_MANUAL.pdf		USER_MANUAL.pdf
agentic_deep_research_systems.md		agentic_deep_research_systems.md
docker-compose.yml		docker-compose.yml
praval_deep_research_logo.png		praval_deep_research_logo.png
pyproject.toml		pyproject.toml
pytest.ini		pytest.ini
requirements-dev.txt		requirements-dev.txt
requirements.txt		requirements.txt
temp_git_setup.sh		temp_git_setup.sh
test_qa_fix.py		test_qa_fix.py
test_qa_quality.py		test_qa_quality.py
test_vajra_integration.py		test_vajra_integration.py

Folders and files

Latest commit

History

Repository files navigation

Praval Deep Research

🎯 What Is This?

Core Philosophy

✨ Key Features

📚 Paper Discovery & Management

💬 Intelligent Conversations

📖 Knowledge Base Management

🔗 Citation Discovery (NEW)

🤖 Praval Agent Architecture

🎨 Modern User Experience

🔍 Vajra BM25 Hybrid Search (NEW)

🔮 Proactive Research Insights (NEW)

⚙️ Settings & Configuration

🏗️ Production-Grade Infrastructure

🚀 Quick Start

Prerequisites

1. Clone and Configure

2. Deploy (One Command)

3. Access Your Research Assistant

🖥️ Desktop App (Tauri)

Download Pre-built Release ⚡

Build From Source

Manual Build (Advanced)

Prerequisites

Build Steps

Build Output Locations

Desktop App Configuration

Using Ollama (Free Local Models)

📖 How It Works

Research Workflow

Example Usage

🏛️ Architecture

System Overview

New Features in Latest Version

🔧 Configuration

Environment Variables

Storage Locations

📊 Monitoring & Management

View Services Status

View Logs

Knowledge Base API

Conversation Management

🧪 Development

Local Development (With Docker for services)

Building for Production

Testing

🌟 Built with Praval

Why Praval?

Learn More About Praval

🗺️ Roadmap

Current (v1.2)

In Progress

Planned

🐛 Troubleshooting

Services Won't Start

Frontend Shows Blank Page

Q&A Returns No Results

Chat History Not Saving

PDF Viewing Not Working

📚 Documentation

📄 License

🙏 Acknowledgments

📞 Support

About

Topics

Resources

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

Packages