🏦 BorrowEase - Peer-to-Peer Lending Platform

BorrowEase is a comprehensive peer-to-peer lending platform that connects borrowers and lenders in a secure, transparent, and user-friendly environment. Built with modern web technologies, it provides a complete ecosystem for loan management, credit scoring, real-time communication, and administrative oversight.

✨ Features Overview

🔐 Authentication & Role Management

Firebase Authentication with secure token-based system
Multi-role Support: Borrowers, Lenders, and Administrators
Profile Management with KYC verification
Protected Routes with role-based access control

💰 Loan Management System

Loan Requests: Borrowers can create detailed loan applications
Loan Approval: Multi-stage approval process with admin oversight
Funding System: Lenders can fund approved loans
Repayment Tracking: Automated payment processing with Razorpay
Interest Calculation: Dynamic interest rate calculations
Loan History: Comprehensive tracking for all parties

🏛️ Advanced Admin Panel

Comprehensive Dashboard with real-time statistics
Loan Moderation: Review and approve/reject loan applications
KYC Management: Verify user identities and documents
User Management: Monitor all platform users
Dispute Resolution: Handle user complaints and issues
Credit Analytics: Platform-wide credit score insights

📊 Credit Scoring System

Multi-factor Algorithm considering:
- Payment History (35%)
- Credit Utilization (30%)
- Credit History Length (15%)
- Loan Diversity (10%)
- Trust Factors (10%)
Real-time Updates based on user activity
Visual Dashboard with circular progress indicators
Credit Improvement Tips and recommendations
Lender Risk Assessment tools

💬 Real-time Communication

Socket.IO Integration for instant messaging
Loan-based Chat Rooms between borrowers and lenders
Real-time Notifications for important events
Message History and chat persistence

🛡️ Dispute Resolution System

Multi-category Disputes: Payment, Communication, Fraud, Technical, Other
Priority Levels: Low, Medium, High, Urgent
Admin Resolution Interface with response tracking
Status Management: Open → In-Progress → Resolved/Rejected
User-friendly Reporting interface

🔔 Notification System

Real-time Notifications for loan updates
Email Integration for important alerts
In-app Notification Bell with unread counts
Notification History and management

💳 Payment Integration

Razorpay Integration for secure payments
Multiple Payment Methods support
Payment Tracking and history
Automated Receipt Generation

🤖 AI-Powered Risk Assessment & Analytics

Comprehensive AI Dashboard with multiple analysis modules
Real-time Risk Scoring using machine learning algorithms
Intelligent Loan Recommendations for lenders
Advanced Fraud Detection system
AI-Powered Repayment Prediction
Borrower Assessment Tools with multi-factor analysis
Platform Analytics with AI-driven insights

🧠 AI Risk Assessment Features

Multi-Model AI System with different algorithms:
- Comprehensive Model: Overall risk assessment
- Quick Assessment: Fast evaluation for urgent decisions
- Conservative Model: Low-risk focused analysis
- Aggressive Model: High-return opportunity identification
Real-time Scoring Metrics:
- Loan-Specific Risk Score (0-100 scale)
- Borrower Trust Score with historical data
- Payment History Analysis with pattern recognition
- Income Verification through AI document analysis
- Credit Utilization intelligent monitoring

🎯 Intelligent Loan Recommendation Engine

Personalized Loan Matching based on lender preferences
Risk Tolerance Configuration:
- Conservative (Low Risk)
- Balanced (Medium Risk)
- Aggressive (High Risk)
Smart Filtering System:
- Minimum confidence thresholds
- Maximum risk limits
- Amount range preferences
- Only AI-approved loans option
Expected Return Calculations with confidence intervals
Timeline Predictions for loan processing and repayment

🛡️ AI Fraud Detection System

Real-time Fraud Monitoring with multiple detection layers
Fraud Type Classification:
- Identity Fraud Detection
- Income Manipulation Detection
- Document Forgery Recognition
- Pattern-based Anomaly Detection
Risk Assessment Metrics:
- Fraud probability scoring
- Confidence levels for each detection
- Automated action recommendations
Prevention Statistics:
- Total applications checked
- Fraud cases flagged
- Financial loss prevented
- AI accuracy rates

📊 AI Repayment Predictor

Repayment Probability Analysis using historical data
Timeline Predictions:
- Optimistic scenario (best case)
- Realistic scenario (most likely)
- Pessimistic scenario (worst case)
Factor Analysis:
- Positive influencing factors with weight calculations
- Risk factors identification and mitigation
- Payment behavior pattern analysis
Smart Recommendations:
- Early reminder scheduling
- Payment incentive suggestions
- Risk mitigation strategies

📈 Platform Analytics & Insights

Loan Performance Metrics with AI-driven analysis
Borrower Behavior Patterns identification
Market Trend Analysis and predictions
Risk Distribution across the platform
Success Rate Optimization recommendations
Lender Portfolio Analysis with performance insights

🔬 Enhanced Loan Cards with AI Integration

Real-time AI Assessment on every loan card
Visual Risk Indicators with color-coded scoring
AI Recommendation Badges:
- ✓ Fund (AI Approved) - Green
- ⚠ Fund (AI Rejected) - Red
- Standard funding options
Smart Details Display:
- Confidence percentages
- Suggested interest rates
- Key risk factors summary
- Top AI recommendations
One-click AI Analysis with detailed breakdowns

🎛️ AI Dashboard Navigation

Multi-tab Interface for comprehensive analysis:
- Risk Assessment Tab: Overall platform risk analysis
- Borrower Analysis Tab: Individual borrower evaluation tools
- Platform Analytics Tab: System-wide performance metrics
- Fraud Detection Tab: Security monitoring dashboard
- AI Models Tab: Model performance and selection

⚡ Real-time AI Features

Live Risk Scoring as loans are created
Dynamic Fraud Monitoring with instant alerts
Automatic Model Updates based on new data
Instant Recommendation Generation for new loan requests
Real-time Dashboard Updates with WebSocket integration

🔄 AI Learning & Adaptation

Continuous Learning from loan outcomes
Model Performance Tracking with accuracy metrics
Feedback Integration from lender decisions
Historical Data Analysis for pattern improvement
Adaptive Risk Thresholds based on market conditions

📱 AI-Enhanced User Experience

Intelligent Loan Matching for optimal pairings
Smart Notification System with AI-driven priorities
Personalized Dashboard with relevant AI insights
Predictive User Interface with proactive suggestions
Context-aware Recommendations based on user behavior

🏗️ Technical Architecture

Backend (Node.js + Express)

Server/
├── config/
│   └── db.js                    # MongoDB connection
├── middleware/
│   └── adminAuth.js             # Admin authentication
├── models/
│   ├── userModel.js             # User schema
│   ├── loanModel.js             # Loan schema
│   ├── disputeModel.js          # Dispute schema
│   ├── chatModel.js             # Chat message schema
│   ├── notificationModel.js     # Notification schema
│   └── auditLogModel.js         # Audit trail schema
├── routes/
│   ├── userRoutes.js            # User management
│   ├── loanroutes.js            # Loan operations
│   ├── disputeRoutes.js         # Dispute handling
│   ├── chatRoutes.js            # Chat functionality
│   ├── notificationRoutes.js    # Notifications
│   ├── paymentRoutes.js         # Payment processing
│   ├── kycRoutes.js             # KYC verification
│   ├── creditRoutes.js          # Credit scoring
│   └── aiRoutes.js              # AI features
├── utils/
│   ├── auditLogger.js           # Audit logging
│   └── interestCalculator.js    # Interest calculations
├── firebase.js                 # Firebase configuration
└── server.js                   # Main server file

Frontend (React + Vite)

Client/
├── public/
├── src/
│   ├── Components/
│   │   ├── Home.jsx                 # Landing page
│   │   ├── Login.jsx                # Authentication
│   │   ├── BorrowerDashboard.jsx    # Borrower interface
│   │   ├── LenderDashboard.jsx      # Lender interface
│   │   ├── AdminDashboard.jsx       # Admin overview
│   │   ├── AdminLoanModeration.jsx  # Loan approval
│   │   ├── AdminKYCManagement.jsx   # KYC verification
│   │   ├── AdminUsers.jsx           # User management
│   │   ├── DisputeModal.jsx         # Dispute creation
│   │   ├── DisputesManagement.jsx   # Admin dispute handling
│   │   ├── CreditScore.jsx          # Credit dashboard
│   │   ├── ChatRoom.jsx             # Real-time messaging
│   │   ├── NotificationBell.jsx     # Notification system
│   │   ├── ComprehensiveAIDashboard.jsx     # AI analytics hub
│   │   ├── EnhancedLoanCard.jsx             # AI-powered loan cards
│   │   ├── AILoanRecommendationEngine.jsx   # Smart loan matching
│   │   ├── AIFraudDetectionDashboard.jsx    # Fraud monitoring
│   │   ├── AIRepaymentPredictor.jsx         # Repayment analysis
│   │   ├── AIRiskAssessment.jsx             # Risk evaluation
│   │   └── ...
│   ├── api/
│   │   ├── api.js                   # API client
│   │   ├── loanApi.js               # Loan operations
│   │   └── notificationApi.js       # Notification API
│   ├── contexts/
│   │   └── SocketContext.jsx        # Socket.IO context
│   ├── firebase.js                 # Firebase client
│   └── main.jsx                    # App entry point
├── index.html
└── vite.config.js

🚀 Getting Started

Prerequisites

Node.js (v16 or higher)
MongoDB (v4.4 or higher)
Firebase account
Razorpay account (for payments)

Installation

Clone the repository

git clone https://github.com/Programmer60/BorrowEase.git
cd BorrowEase

Backend Setup
```
cd Server
npm install
```
Frontend Setup
```
cd ../Client
npm install
```

Environment Configuration

Firebase Setup

Create a Firebase project at Firebase Console
Enable Authentication (Email/Password)
Create a Service Account key in Firebase → Project Settings → Service Accounts → Generate new private key.
Do NOT commit this file. Instead, set these environment variables on the server:
- FIREBASE_PROJECT_ID
- FIREBASE_CLIENT_EMAIL
- Either FIREBASE_PRIVATE_KEY_BASE64 (preferred; base64-encode the full private key) or FIREBASE_PRIVATE_KEY (escaped newlines as \n)
For the client (web SDK), set the VITE_FIREBASE_* values from your Firebase Web App settings in Client/.env.

MongoDB Setup
- Create MongoDB database (local or Atlas)
- Update connection string in Server/config/db.js
Razorpay Setup
- Create Razorpay account
- Get API keys from dashboard
- Add to environment variables
Environment Variables

Copy the provided examples and fill in values (never commit real secrets):

Server: Server/.env.example → Server/.env
Client: Client/.env.example → Client/.env

Minimal examples below (refer to the examples in the repo for the full list):

Server/.env

PORT=5000
# Database
MONGO_URI=your_mongodb_connection_string
 
# CORS allowlist (comma-separated)
CORS_ORIGIN=http://localhost:5173,https://your-frontend-domain.com
 
# Firebase Admin (server-side)
FIREBASE_PROJECT_ID=your_firebase_project_id
FIREBASE_CLIENT_EMAIL=your_service_account_email@your-project.iam.gserviceaccount.com
# Prefer base64 to avoid newline escaping issues
FIREBASE_PRIVATE_KEY_BASE64=base64_of_your_private_key
# Or use the raw key with \n newlines escaped
# FIREBASE_PRIVATE_KEY="-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----\n"
 
# Cloudinary (server-side signing)
CLOUDINARY_CLOUD_NAME=your_cloud_name
CLOUDINARY_API_KEY=your_api_key
CLOUDINARY_API_SECRET=your_api_secret
 
# Payments
RAZORPAY_KEY_ID=your_razorpay_key_id
RAZORPAY_KEY_SECRET=your_razorpay_key_secret

Client/.env

VITE_FIREBASE_API_KEY=your_firebase_api_key
VITE_FIREBASE_AUTH_DOMAIN=your_project.firebaseapp.com
VITE_FIREBASE_PROJECT_ID=your_firebase_project_id
VITE_FIREBASE_STORAGE_BUCKET=your_project.appspot.com
VITE_FIREBASE_MESSAGING_SENDER_ID=your_sender_id
VITE_FIREBASE_APP_ID=your_app_id

Running the Application

Start the Backend Server
```
cd Server
npm start
```
Start the Frontend Development Server
```
cd Client
npm run dev
```
Access the Application
- Frontend: http://localhost:5173
- Backend API: http://localhost:5000

🤖 AI Features Usage Guide

Accessing AI Dashboard

Navigate to AI Dashboard: Available in navigation for lenders and admins
Multi-tab Interface: Switch between different AI analysis modules
Real-time Updates: All AI assessments update automatically

AI-Enhanced Loan Cards

Automatic Assessment: AI analysis runs automatically for lenders
Manual Refresh: Click "Get AI Assessment" for on-demand analysis
Color-coded Indicators:
- 🟢 Green: AI Approved (Low Risk)
- 🔵 Blue: Moderate Risk
- 🟡 Yellow: Higher Risk
- 🔴 Red: AI Rejected (High Risk)

Smart Loan Recommendations

Set Preferences: Configure risk tolerance and amount ranges
AI Matching: System finds optimal loan opportunities
Confidence Filtering: Adjust minimum confidence levels
One-click Investment: Direct funding from recommendations

Fraud Detection Monitoring

Real-time Alerts: Automatic fraud detection notifications
Admin Actions: Resolve alerts with recommended actions
Performance Tracking: Monitor system effectiveness
Risk Trends: View borrower risk score evolution

Repayment Predictions

Timeline Forecasting: View optimistic, realistic, and pessimistic scenarios
Factor Analysis: Understand what influences repayment probability
Smart Reminders: AI suggests optimal reminder timing
Risk Mitigation: Get recommendations to improve repayment likelihood

🎯 User Roles & Permissions

👤 Borrowers

Create and manage loan requests
View loan history and status
Make payments through integrated system
Chat with lenders for funded loans
Monitor personal credit score
Submit disputes for issues

🏦 Lenders

Browse and filter loan requests
View borrower credit scores
Access AI loan recommendations with smart matching
Real-time AI risk assessment on all loans
Fund approved loans with AI guidance
Track funded loan performance
AI-powered repayment predictions for funded loans

🧩 Recent Fix: Payment failure/cancel redirect UX (Aug 2025)

Issue observed

Clicking “Failure” in Razorpay sometimes showed “Cannot GET /api/payment/callback”, or redirected borrowers to /lender where a role-guard popped “Access denied. You are not a lender.”

What we changed (server)

Added GET /api/payment/callback to handle Razorpay GET-style redirects on failure, mirroring the POST handler.
Both POST and GET /api/payment/callback now render a small branded interstitial page and then auto-redirect back to the SPA with clear query params.
POST /api/payment/create-order now returns checkoutUrl that points to the server-hosted checkout page and includes a fallback role parameter:
- Repayment → ?fallback=borrower
- Funding → ?fallback=lender
Server-hosted checkout pages forward fallback into Razorpay’s callback_url so, even if orderId is missing, the callback knows which dashboard to return to.
Callback picks destination by reading the order’s notes.isRepayment; if unavailable, it falls back to the ?fallback value.

What we changed (client)

BorrowerDashboard and LenderDashboard:
- Show a friendly banner after redirect based on ?payment=success|failed&reason=...
- Persist last_order_id and, if the user closes the gateway without redirect, poll GET /api/payment/status/:orderId once to resolve status.
- Clean the query string after showing the banner.

Expected behavior

On cancel/failure: you briefly see an interstitial page, then land on /borrower or /lender with a banner and URL like:
- /borrower?payment=failed&order=order_...&code=...&reason=...
- /lender?payment=failed&order=order_...&code=...&reason=...
On success: you land on the correct dashboard with ?payment=success and a success banner.

Endpoints involved

POST /api/payment/create-order → returns { id, amount, …, checkoutUrl }
GET /api/payment/checkout/:orderId[?fallback=role]
POST /api/payment/callback (success/failure)
GET /api/payment/callback (failure or when gateway uses GET)
GET /api/payment/status/:orderId (dashboard polling fallback)

Quick test

Start backend and frontend.
As a borrower, initiate a repayment and click Failure in Razorpay → you should be redirected to /borrower with a “Payment failed” banner.
As a lender, initiate funding and click Failure → redirected to /lender with a “Payment failed” banner.
Close the gateway without redirect → on next load, dashboard polls status for last_order_id and shows the proper banner.

Troubleshooting

If you see “Cannot GET /api/payment/callback”, ensure the API has the new GET route and has been restarted.
If redirected to the wrong dashboard, check that checkoutUrl contains ?fallback=borrower or ?fallback=lender and that callback_url also includes the same fallback.
See PAYMENT_DEBUG_GUIDE.md for deeper diagnostics.
Communicate with borrowers
Submit disputes for problems

👨‍💼 Administrators

Complete platform oversight
Approve/reject loan applications
Manage KYC verification process
Handle dispute resolution
Comprehensive AI analytics dashboard access
Advanced fraud detection monitoring
AI model performance tracking
Platform-wide risk assessment tools
Monitor platform statistics
Manage user accounts
Access credit analytics

📊 API Documentation

Authentication Endpoints

POST /api/users/register     # User registration
POST /api/users/login        # User login
GET  /api/users/me           # Get current user
PUT  /api/users/profile      # Update profile

Loan Management

POST /api/loans              # Create loan request
GET  /api/loans              # Get all loans (admin)
GET  /api/loans/my-loans     # Get user's loans
GET  /api/loans/funded       # Get funded loans
PUT  /api/loans/:id/approve  # Approve loan (admin)
PUT  /api/loans/:id/fund     # Fund loan (lender)
PUT  /api/loans/:id/repay    # Repay loan (borrower)

Credit Scoring

GET  /api/credit/score           # Get user's credit score
GET  /api/credit/score/:userId   # Get specific user's score
GET  /api/credit/history         # Get credit history
GET  /api/credit/admin/stats     # Get platform credit stats

Dispute Management

POST  /api/disputes              # Create dispute
GET   /api/disputes              # Get disputes
GET   /api/disputes/loan/:id     # Get loan disputes
PATCH /api/disputes/:id/resolve  # Resolve dispute (admin)
GET   /api/disputes/admin/stats  # Get dispute statistics

Chat & Notifications

GET  /api/chat/:loanId           # Get chat messages
POST /api/chat/:loanId           # Send message
GET  /api/notifications          # Get notifications
PUT  /api/notifications/:id/read # Mark as read

AI & Machine Learning

POST /api/ai/assess-borrower     # AI borrower risk assessment
POST /api/ai/recommend-loans     # Get AI loan recommendations
GET  /api/ai/fraud-detection     # Fraud detection analysis
GET  /api/ai/risk-scores         # Platform risk scoring
POST /api/ai/predict-repayment   # Repayment probability prediction
GET  /api/ai/platform-analytics  # AI-driven platform insights
GET  /api/ai/risk-assessment     # Comprehensive risk analysis
POST /api/ai/fraud-alerts/:id/resolve  # Resolve fraud alerts
GET  /api/ai/model-performance   # AI model accuracy metrics
POST /api/ai/borrower-analysis   # Individual borrower evaluation

🛡️ Security Features

JWT Token Authentication with Firebase
Role-based Access Control (RBAC)
Input Validation and sanitization
SQL Injection Protection through MongoDB
XSS Protection with proper data handling
CORS Configuration for secure cross-origin requests
Audit Logging for sensitive operations
Secure Payment Processing through Razorpay

See SECURITY.md for public-repo readiness and a secrets hygiene checklist.

📱 Responsive Design

Mobile-first Approach with Tailwind CSS
Progressive Web App capabilities
Cross-browser Compatibility
Adaptive UI Components
Touch-friendly Interface

🔧 Development Features

AI Technical Implementation

Machine Learning Models

// AI Risk Assessment Models
const aiModels = {
  comprehensive: {
    name: "Comprehensive Risk Model",
    accuracy: 94.2,
    factors: ["creditHistory", "paymentBehavior", "incomeStability", "loanPurpose"],
    weightings: { creditHistory: 0.35, paymentBehavior: 0.30, income: 0.25, other: 0.10 }
  },
  quickAssessment: {
    name: "Quick Assessment Model", 
    accuracy: 89.1,
    speed: "< 1 second",
    factors: ["creditScore", "paymentHistory", "basicVerification"]
  },
  fraudDetection: {
    name: "Fraud Detection Model",
    accuracy: 96.8,
    detectionTypes: ["identity", "income", "document", "behavioral"]
  }
};

AI API Integration

// Real-time AI Assessment
const fetchAIAssessment = async (borrowerData) => {
  const response = await API.post('/ai/assess-borrower', {
    borrowerId: borrowerData.id,
    loanAmount: borrowerData.amount,
    loanPurpose: borrowerData.purpose,
    modelType: 'comprehensive'
  });
  return response.data;
};

// Fraud Detection
const checkFraud = async (applicationData) => {
  const response = await API.post('/ai/fraud-detection', {
    applicantData: applicationData,
    documentImages: applicationData.documents,
    behavioralMetrics: applicationData.behavior
  });
  return response.data;
};

AI Component Architecture

// Enhanced Loan Card with AI
const EnhancedLoanCard = ({ loan, showAIFeatures = true }) => {
  const [aiAssessment, setAiAssessment] = useState(null);
  const [loading, setLoading] = useState(false);
  
  // Auto-fetch AI assessment for lenders
  useEffect(() => {
    if (showAIFeatures && userRole === 'lender') {
      fetchAIAssessment();
    }
  }, [loan.borrowerId]);
  
  // Real-time scoring with color-coded indicators
  const getScoreColor = (score) => {
    if (score >= 80) return 'text-green-600 bg-green-50';
    if (score >= 60) return 'text-blue-600 bg-blue-50';
    return 'text-red-600 bg-red-50';
  };
};

AI Dashboard State Management

// Comprehensive AI Dashboard
const ComprehensiveAIDashboard = () => {
  const [activeTab, setActiveTab] = useState('risk-assessment');
  const [aiModels, setAiModels] = useState([]);
  const [fraudAlerts, setFraudAlerts] = useState([]);
  const [platformAnalytics, setPlatformAnalytics] = useState(null);
  
  // Multi-tab AI interface
  const tabs = [
    { id: 'risk-assessment', component: RiskAssessmentTab },
    { id: 'fraud-detection', component: FraudDetectionTab },
    { id: 'loan-recommendations', component: RecommendationEngine },
    { id: 'platform-analytics', component: AnalyticsTab }
  ];
};

Code Quality

ESLint Configuration for code standards
Prettier Integration for formatting
Component-based Architecture
Modular API Design
Error Handling throughout the application

Performance Optimization

Lazy Loading for route components
Image Optimization with modern formats
Bundle Splitting with Vite
Database Indexing for faster queries
Caching Strategies for API responses

🚀 Deployment

Backend Deployment (Railway/Heroku)

# Build for production
npm run build

# Set environment variables
# Deploy using platform-specific commands

Frontend Deployment (Vercel/Netlify)

# Build for production
npm run build

# Deploy dist folder
# Configure environment variables

Database Deployment

MongoDB Atlas for cloud database
Proper indexing for performance
Backup strategies for data protection

📈 Current AI Capabilities & Future Enhancements

✅ Implemented AI Features

AI-powered Risk Assessment with multiple machine learning models
Intelligent Fraud Detection with real-time monitoring
Smart Loan Recommendations based on lender preferences
Repayment Prediction using historical data analysis
Comprehensive AI Dashboard with multiple analysis modules
Enhanced Loan Cards with real-time AI integration
Platform Analytics with AI-driven insights

🚀 Future AI Enhancements

Deep Learning Models for more accurate predictions
Natural Language Processing for document analysis
Computer Vision for ID and document verification
Predictive Market Analysis for interest rate optimization
Behavioral Analysis for enhanced fraud detection
Automated Loan Approval with minimal human intervention
Voice Recognition for customer verification
Sentiment Analysis from chat communications

🔮 Other Planned Features

Mobile Applications (React Native)
Multi-currency Support for international users
Integration with Banking APIs for verification
Blockchain Integration for transparency
Advanced Risk Assessment tools
Regulatory Compliance modules

🤝 Contributing

Fork the repository
Create a feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

👥 Team

Developer: Shivam Mishra
Project Type: Full-stack Web Application
Development Period: 2025

📞 Support

For support and questions:

Create an issue in the GitHub repository
Contact the development team
Check the documentation for common solutions

Built with ❤️ by Shivam Mishra

BorrowEase - Making peer-to-peer lending simple, secure, and transparent.

Name		Name	Last commit message	Last commit date
Latest commit History 65 Commits
Client		Client
Server		Server
.gitattributes		.gitattributes
.gitignore		.gitignore
.gitleaks.toml		.gitleaks.toml
LICENSE		LICENSE
README.md		README.md

Folders and files

Latest commit

History

Repository files navigation