Intelli-Credit

Enterprise-Grade AI-Powered Corporate Credit Underwriting and Loan Analysis

Intelli-Credit is an advanced AI-powered corporate credit underwriting and loan analysis platform. Designed for financial institutions and credit officers, it automates the ingestion of corporate financial documents, performs secondary market research, runs data verification, and generates explainable loan recommendations alongside standardized Credit Appraisal Memos (CAM).

---

🧭 Live Platform & Demo Access

The platform is deployed live and configured for public demonstration:

• Web Client: www.intellicredit.tech (Hosted on Vercel)
• Backend API: AWS EC2 instance orchestrated via Docker Compose and GitHub Actions CI/CD.
• Database Layer: Fully hosted Supabase PostgreSQL instance.

Demo Credentials

To bypass the signup flow, use the pre-seeded credit officer account:

• Email: demo@bank.com
• Password: demo123
• Role: Credit Officer (Full access to all dashboard analytics, upload panels, SWOT matrices, and CAM report generators).

---

⚡ Core Pipeline & Interactive Walkthrough

The platform runs a multi-agent processing pipeline, executing analysis across several evaluation vectors:

📂 1. Multi-Document Ingestion & Classification

• Multiple File Formats: Credit officers can upload 5 specific corporate financial documents simultaneously (Asset Liability Management (ALM), Shareholding, Borrowing, Annual Report, and Portfolio).
• Automated Type Classification: The backend analyzes document headers, layouts, and page structures to classify the uploaded PDFs.
• Review & Ingestion Gate: Provides a classification confirmation interface before kicking off execution.

📊 2. Financial Extraction & Ratios

• LLM-Based Data Extraction: Uses Groq (Llama-3.3-70b) and Ollama instances to extract key financial parameters (Revenue, Profit, Assets, Liabilities, Equity) from raw text.
• Automated Financial Ratios: Calculates critical leverage and liquidity ratios including:
  • Profit Margin (Net Income / Revenue)
  • Debt-to-Equity Ratio (Total Liabilities / Shareholder Equity)
  • Leverage Ratio (Total Assets / Shareholder Equity)
  • Current Ratio (Current Assets / Current Liabilities)

🔍 3. Market Intelligence & Secondary Research

• Multi-Source News Ingestion: Integrates with NewsAPI to query external regulatory bodies, market indices, and news portals.
• Granular Sentiment Analysis: Applies TextBlob sentiment scoring across five custom research components:
  • Regulatory compliance news (RBI, SEBI, corporate governance metrics)
  • Market & financial performance announcements
  • Competitor landscape & peer analysis
  • Media coverage volume and reputation metrics
  • Overall sector & industry trends

🛡️ 4. Data Triangulation & Validation

• Anomaly Detection: Cross-checks extracted financial declarations against public market sentiment. It alerts underwriters when there is a significant mismatch between reported profits and external news sentiment.
• Red Flag Framework: Flags regulatory defaults, late filings, compliance issues, and negative news mentions.
• System Confidence Score: Dynamically calculates an overall confidence metric (0-100) based on source completeness, data alignment, and risks detected.

🗺️ 5. Strategic SWOT Analysis

• LLM-Driven Strategic Assessment: Orchestrates an Ollama model (Qwen 8B) to generate a detailed 4-panel SWOT matrix tailored specifically to the company's financial results and media footprint.
• Weighted Strategic Factors: Categorizes strengths, weaknesses, opportunities, and threats with individual impact levels (High/Medium/Low) backed by extracted evidence.

📝 6. Explainable Loan Recommendation

• Dynamic Scoring Algorithm: Computes a composite loan score weighing financial health, credit risk metrics, and data quality confidence.
• Approval Decisioning: Categorizes applications as APPROVE, CONDITIONAL_APPROVE, or REJECT using deterministic risk rules.
• Standardized Credit Appraisal Memo (CAM): Compiles the full profile into a formatted appraisal report that can be exported or printed directly from the UI.

---

🛠️ Technology Stack

Layer	Technology	Purpose
Frontend	React, Vite, TailwindCSS, Axios	Responsive Single Page Application (SPA), interactive charts, and dashboard navigation.
Backend	FastAPI (Python 3.10+), SQLAlchemy	High-performance async REST API endpoints, routing, and processing orchestrator.
Database	PostgreSQL (Supabase)	Persistent user records, upload audits, metadata tables, and system logs.
Orchestration	Docker, Docker Compose	Containerization for consistent environments across development and production EC2 nodes.
AI / NLP	Groq API (Llama 3.3), Ollama (Qwen)	Financial parameter extraction, TextBlob sentiment scoring, and SWOT analysis.
CI / CD	GitHub Actions	Automated Docker image building, GHCR registry push, and target EC2 deployment updates.

---

📐 System Architecture & Data Flow

Below is the workflow showing the sequential processing pipeline:

                  ┌──────────────────────┐
                  │ 5 PDF Documents      │ (ALM, Shareholding, Borrowing,
                  │ + Company Name       │  Annual Report, Portfolio)
                  └──────────┬───────────┘
                             │
                             ▼
                  ┌──────────────────────┐
                  │   FastAPI Backend    │ (Multi-Agent Processing Engine)
                  └──────────┬───────────┘
                             │
      ┌──────────────────────┼──────────────────────┐
      ▼                      ▼                      ▼
┌───────────┐          ┌───────────┐          ┌───────────┐
│ PDF Text  │          │  Ollama   │          │  NewsAPI  │
│ Extractor │          │ (Qwen 8B) │          │ TextBlob  │
└─────┬─────┘          └─────┬─────┘          └─────┬─────┘
      │ (Text Ingest)        │ (SWOT Engine)        │ (Sentiment Analysis)
      ▼                      ▼                      ▼
┌───────────┐          ┌───────────┐          ┌───────────┐
│ Financial │          │ Strategic │          │ Secondary │
│ Ratios    │          │ SWOT Grid │          │ Research  │
└─────┬─────┘          └─────┬─────┘          └─────┬─────┘
      │                      │                      │
      └──────────────────────┼──────────────────────┘
                             │ (Data Feeds)
                             ▼
                  ┌──────────────────────┐
                  │ Triangulation Engine │ (Validates Mismatches & Anomaly Flags)
                  └──────────┬───────────┘
                             │
                             ▼
                  ┌──────────────────────┐
                  │Recommendation Engine │ (Decision: Approve / Conditional / Reject)
                  └──────────┬───────────┘
                             │
                             ▼
                  ┌──────────────────────┐
                  │  React Client (UI)   │ (8-Tab Financial Analysis Dashboard)
                  └──────────────────────┘

---

🚀 Local Development Setup

To run the entire platform locally, configure the backend and frontend components using the steps below.

Prerequisites

• Python 3.10+
• Node.js 18+
• Ollama Client (installed and running locally)

---

1. Environment Configuration

Create a .env file in the project root directory. Use the template below:

# Database Settings
DATABASE_URL=sqlite:///./intelli_credit.db  # Use PostgreSQL URL for cloud setup

# AI & LLM Keys
GROQ_API_KEY=your_groq_api_key_here
GROQ_MODEL=llama-3.3-70b-versatile
OLLAMA_URL=http://localhost:11434
LLM_MODEL=qwen3:8b

# External Integrations
NEWS_API_KEY=your_newsapi_key_here  # Leave blank to use fallback mock news data

# Security
JWT_SECRET_KEY=change-this-to-a-random-32-char-secret
JWT_ENCRYPTED_SECRET=change-this-to-another-random-secret
AES_ENCRYPTION_KEY=change16bytekey!

---

2. Backend & Ollama Setup

1. Start the local Ollama Service: Ensure Ollama is running, then pull the target SWOT model:

   ollama pull qwen3:8b

2. Navigate to the project root and build the virtual environment:

   python -m venv .venv

3. Activate the virtual environment:

   • Windows PowerShell:

     .\.venv\Scripts\Activate.ps1

   • macOS / Linux:

     source .venv/bin/activate

4. Install Python packages:

   pip install -r requirements.txt

5. Initialize and Seed the Database: Drops any lingering tables and configures the database schema:

   # Set Python path to project root
   $env:PYTHONPATH="."
   
   python scratch/clean_db.py

6. Start the Uvicorn Dev Server:

   python backend/run.py

   • Backend API server runs on: http://localhost:8000
   • API documentation & Swagger portal: http://localhost:8000/docs

---

3. Frontend Setup

1. Navigate to the frontend directory:

   cd frontend

2. Install Node modules:

   npm install

3. Launch the development server:

   npm run dev

   • Frontend local server runs on: http://localhost:5173 (or similar)
   • The client proxy automatically routes /api calls to the backend on port 8000.

---

🧪 Testing & Verification

We use pytest to test the API route logic, extraction processes, and validation engines.

To run the complete test suite locally:

# Set Python path to project root
$env:PYTHONPATH="."

pytest backend

---

📦 Production Deployment

Backend (AWS EC2 + Docker)

The backend service builds through a GitHub Actions workflow on pushing changes to main.

1. Builds a production Docker image using backend/Dockerfile.
2. Pushes the image to GitHub Container Registry (GHCR).
3. Connects to the AWS EC2 instance via SSH and deploys the container using docker compose -f docker-compose.prod.yml up -d.

Frontend (Vercel)

The frontend React app is linked to Vercel for continuous integration and hosting:

• Automated previews on pull requests.
• Direct production deployments on merges to main.
• Configured with production environment pointing directly to the AWS EC2 backend API endpoints.