ERNIE FinSight - AI Crypto Whitepaper Analyzer

Overview

ERNIE FinSight is an intelligent crypto whitepaper analyzer that leverages Baidu’s ERNIE 4.5 multimodal AI model (via Novita AI API) to extract, analyze, and present complex whitepaper information in a beautiful, accessible web interface. Built for the Baidu ERNIE AI Developer Challenge, this project transforms the tedious process of analyzing cryptocurrency whitepapers into an instant, AI-powered experience.

The application provides comprehensive insights including executive summaries, tokenomics analysis, roadmap extraction, risk assessment, and competitive advantages, all presented in a modern, financial-themed dashboard with smooth animations and professional UX.

🌐 Live Demo: ernie-fin-sight.vercel.app

🔧 Backend API: ernie-finsight.onrender.com

The Challenge

Cryptocurrency investors and analysts face significant challenges when evaluating new projects:

Information Overload - Whitepapers are often 50-100+ pages of dense technical content
Time Constraints - Reading and analyzing multiple projects is extremely time-consuming
Technical Complexity - Understanding tokenomics, technology stack, and architecture requires expertise
Risk Assessment - Identifying potential red flags and risks demands careful analysis
Comparison Difficulty - Evaluating multiple projects side-by-side is impractical

ERNIE FinSight solves these problems by providing instant, comprehensive AI-powered analysis in seconds instead of hours.

Key Features

📄 PDF Upload & Processing

Drag-and-drop interface with real-time progress tracking and validation. Supports PDF whitepapers up to 10MB with instant upload confirmation.

🧠 ERNIE AI Analysis

Leverages Baidu’s ERNIE 4.5 multimodal model through Novita AI API for comprehensive document understanding and structured data extraction.

💎 Beautiful Dashboard

Modern, financial-themed UI with glassmorphism design, smooth Framer Motion animations, and responsive layouts optimized for all devices.

📊 Structured Insights

Extracts and presents:

Executive Summary - High-level project overview
Key Value Propositions - Unique selling points and benefits
Technology Stack - Technical architecture and blockchain details
Tokenomics - Token distribution, supply, and economic model
Roadmap - Development phases and milestones
Team & Partnerships - Key team members and strategic partners
Risk Factors - Potential concerns and red flags
Competitive Advantages - Market differentiators
Target Audience - User demographics and use cases
Overall Assessment - AI-generated project evaluation

⚡ Fast & Async

Non-blocking background processing with real-time status updates. Users receive immediate task IDs and can track analysis progress through polling endpoints.

Technical Architecture

Backend Stack

Core Framework:

FastAPI - Modern, high-performance Python web framework
Pydantic - Data validation and settings management
Python 3.9+ - Latest Python features and type hints

AI Integration:

Novita AI API - Access to Baidu’s ERNIE models
ERNIE 4.5 VL - Multimodal vision-language model for document understanding
Structured Prompts - Engineered prompts for consistent JSON output

PDF Processing:

PyPDF2 - PDF text extraction
pdfplumber - Advanced PDF content parsing
Text Chunking - Intelligent content segmentation for API limits

File Management:

aiofiles - Async file operations
UUID - Task tracking and file identification
Environment Variables - Secure configuration management

Frontend Stack

Core Technologies:

React 18 - Modern UI library with concurrent features
TypeScript - Full type safety and developer experience
Vite - Lightning-fast build tool and dev server

Styling & UI:

Tailwind CSS - Utility-first styling framework
Framer Motion - Smooth, performant animations
Glassmorphism Design - Modern, translucent card effects
Responsive Design - Mobile-first approach

State Management & Routing:

React Router - Client-side routing and navigation
React Hooks - State and effect management
Axios - HTTP client for API communication

UX Features:

Loading Skeletons - Smooth loading states
Error Boundaries - Graceful error handling
Progress Indicators - Real-time status updates
Toast Notifications - User feedback system

How It Works

User Flow

1. Upload PDF
   ↓
   - User drags/drops whitepaper or clicks to select
   - Frontend validates file (PDF, <10MB)
   - Uploads to backend API
   - Receives task ID immediately

2. Background Processing
   ↓
   - Backend extracts text from PDF
   - Chunks content for API processing
   - Sends to ERNIE 4.5 VL via Novita API
   - Parses structured JSON response

3. Status Polling
   ↓
   - Frontend polls /api/status/{task_id}
   - Shows progress percentage
   - Updates UI with loading animations

4. Results Display
   ↓
   - Fetches completed analysis from /api/result/{task_id}
   - Renders beautiful dashboard with all insights
   - Enables user to download or share results

API Workflow

Upload Endpoint (POST /api/upload):

1. Receive PDF file from multipart form
2. Validate file size and type
3. Generate unique task ID (UUID)
4. Save file to uploads directory
5. Start background analysis task
6. Return task ID to client

Processing Logic:

1. Extract text from PDF using PyPDF2/pdfplumber
2. Clean and chunk text content
3. Build structured prompt for ERNIE model
4. Send request to Novita AI API
5. Parse JSON response into Pydantic models
6. Store results in memory with task ID
7. Update task status to "completed"

Status Endpoint (GET /api/status/{task_id}):

1. Check if task exists
2. Return current status (pending/processing/completed/failed)
3. Include progress percentage
4. Return error message if failed

Result Endpoint (GET /api/result/{task_id}):

1. Validate task is completed
2. Retrieve analysis results from storage
3. Return structured JSON with all insights
4. Handle errors gracefully

API Documentation

Endpoints

`POST /api/upload`

Upload a PDF whitepaper for analysis.

Request:

POST /api/upload HTTP/1.1
Content-Type: multipart/form-data

file: whitepaper.pdf (max 10MB)

Response:

{
  "task_id": "550e8400-e29b-41d4-a716-446655440000",
  "filename": "whitepaper.pdf",
  "message": "File uploaded successfully. Processing started."
}

`GET /api/status/{task_id}`

Check processing status and progress.

Response:

{
  "task_id": "550e8400-e29b-41d4-a716-446655440000",
  "status": "processing",
  "progress": 50,
  "message": null
}

Status Values: pending, processing, completed, failed

`GET /api/result/{task_id}`

Retrieve complete analysis results.

Response:

{
  "task_id": "550e8400-e29b-41d4-a716-446655440000",
  "status": "completed",
  "result": {
    "project_name": "Example Token",
    "executive_summary": "Comprehensive overview...",
    "key_value_propositions": ["Proposition 1", "Proposition 2"],
    "technology_stack": {
      "blockchain": "Ethereum",
      "consensus": "PoS"
    },
    "tokenomics": {
      "total_supply": "1,000,000,000",
      "distribution": {...}
    },
    "roadmap": [
      {"phase": "Q1 2025", "milestones": [...]}
    ],
    "team_and_partnerships": {...},
    "risk_factors": ["Risk 1", "Risk 2"],
    "competitive_advantages": ["Advantage 1", "Advantage 2"],
    "target_audience": ["Investors", "Developers"],
    "use_cases": ["Use case 1", "Use case 2"],
    "overall_assessment": "AI-generated evaluation..."
  }
}

Installation & Deployment

Prerequisites

Python 3.9+ - Backend runtime
Node.js 18+ - Frontend development
Novita AI API Key - Get one here

Local Development

Backend Setup:

# Navigate to backend directory
cd backend

# Install dependencies
pip install -r requirements.txt

# Configure environment
cat > .env << EOF
NOVITA_API_KEY=your_novita_api_key_here
MAX_FILE_SIZE_MB=10
UPLOAD_DIR=./uploads
EOF

# Run the server
python main.py
# API available at http://localhost:8000

Frontend Setup:

# Navigate to frontend directory
cd frontend

# Install dependencies
npm install

# Run development server
npm run dev
# App available at http://localhost:5173

Production Deployment

Frontend (Vercel):

# Build for production
npm run build

# Preview build
npm run preview

# Deploy to Vercel
# Automatic deployments configured via GitHub integration

Backend (Render):

# Set environment variables in Render dashboard
NOVITA_API_KEY=your_key
MAX_FILE_SIZE_MB=10

# Configure build command
pip install -r requirements.txt

# Configure start command
uvicorn main:app --host 0.0.0.0 --port 8000

Health Check Endpoint: https://ernie-finsight.onrender.com/api/health

Use Cases

💰 Crypto Investors

Quickly evaluate new projects before investment decisions. Get comprehensive insights in seconds instead of spending hours reading dense whitepapers.

📊 Financial Analysts

Conduct thorough due diligence across multiple projects. Compare tokenomics, roadmaps, and risk factors efficiently.

🔍 Due Diligence Teams

Systematic risk assessment and project evaluation. Identify red flags and competitive advantages at scale.

🎓 Research & Education

Academic analysis of blockchain projects. Learn about different token models, governance structures, and technical architectures.

🏢 Investment Firms

Streamline project screening process. Build comparison matrices across portfolio candidates quickly.

What Makes This Special

For the Hackathon

✨ ERNIE Multimodal Capabilities - Showcases ERNIE’s advanced document understanding and structured data extraction

🔧 Novita AI Integration - Uses Novita AI API for ERNIE 4.5 VL access (qualifying for sponsored category)

💡 Practical Use Case - Solves real problem for crypto investors and analysts worldwide

🏗️ Professional Quality - Production-ready code with proper architecture, error handling, and deployment

Technical Highlights

⚡ Async Processing - Non-blocking analysis with real-time status updates

🎯 Structured Prompts - Carefully engineered prompts for consistent, parseable JSON output

🛡️ Error Handling - Graceful failures with helpful error messages and fallback strategies

🔒 Type Safety - Full TypeScript frontend + Pydantic backend validation

📐 Clean Architecture - Separation of concerns, modular design, scalable codebase

🚀 Performance Optimized - Fast loading, efficient rendering, minimal API calls

Project Evolution

Built over the course of the Baidu ERNIE AI Developer Challenge:

Concept Phase - Identified pain point in crypto whitepaper analysis
Architecture Design - Planned FastAPI + React stack with ERNIE integration
Backend Development - Built API, PDF processing, and Novita AI integration
Frontend Development - Created React UI with beautiful dashboard components
Integration & Testing - Connected all pieces, tested with real whitepapers
Deployment - Launched on Vercel (frontend) and Render (backend)
Polish & Documentation - Final UX improvements, comprehensive docs

Hackathon Submission

Competition: Baidu ERNIE AI Developer Challenge
Platform: DevPost
Category: Best ERNIE Multimodel Application (Sponsored by Novita)
Status: Qualifying Entry

Links:

🌐 Live Demo: ernie-fin-sight.vercel.app
📹 Video Demo: Watch on Vimeo
💻 GitHub: github.com/Sterbweise/ERNIE-FinSight
🏆 DevPost: devpost.com/software/finsight-y213il

License

MIT License - Open source and free to use

Acknowledgments

Baidu - For the amazing ERNIE AI models and innovation in multimodal AI
Novita AI - For providing accessible ERNIE API and supporting the hackathon
DevPost - For hosting the Baidu ERNIE AI Developer Challenge

Support & Resources

GitHub Repository: github.com/Sterbweise/ERNIE-FinSight
Issues & Bugs: github.com/Sterbweise/ERNIE-FinSight/issues
DevPost Submission: devpost.com/software/finsight-y213il

Project Status: Hackathon Complete | Tech Stack: FastAPI + React + ERNIE 4.5 VL | Built: January 2025