• ✨ Features
• 🏗️ Architecture
• 🚀 Getting Started
• 🛠️ Installation
• ⚙️ Configuration
• 📊 Dashboard
• 🔧 API Reference
• 🌐 Multi-Platform Support
• 📈 Monitoring & Analytics
• 🔒 Security
• 🤝 Contributing
• 📄 License

• Professional Dashboard - Real-time metrics, system health, and KPI monitoring
• Advanced Statistics - Multi-dimensional analytics with interactive visualizations
• Request Logging - Comprehensive audit trails with filtering and search capabilities
• Cost Analysis - Financial tracking with detailed flow analysis and forecasting
• User Management - Secure authentication with role-based permissions

graph TB
    subgraph "Frontend (React 19)"
        A[Admin Dashboard] --> B[API Key Manager]
        A --> C[Analytics Dashboard]
        A --> D[Account Manager]
        A --> E[Request Logger]
    end
    
    subgraph "Backend (.NET 9 API)"
        F[Authentication Service] --> G[Proxy Engine]
        G --> H[Rate Limiter]
        H --> I[Cost Calculator]
        I --> J[Request Logger]
    end
    
    subgraph "AI Platforms"
        K[Claude/Anthropic]
        L[OpenAI]
        M[Google Gemini]
    end
    
    subgraph "Data Layer"
        N[SQLite Database]
        O[Memory Cache]
    end
    
    A --> F
    G --> K
    G --> L
    G --> M
    J --> N
    I --> O

• .NET 9 SDK
• Node.js 20+
• npm/yarn/pnpm

1. Clone the repository

   git clone https://github.com/AIDotNet/ClaudeCodeProxy.git
   cd ClaudeCodeProxy

2. Start the backend

   cd src/ClaudeCodeProxy.Host
   dotnet restore
   dotnet run

3. Start the frontend

   cd web
   npm install
   npm run dev

4. Access the application

   • Frontend: http://localhost:5173
   • Backend API: http://localhost:5000
   • Swagger UI: http://localhost:5000/scalar/v1

# Build and run with Docker Compose
docker-compose up -d

1. Backend Setup

   cd src/ClaudeCodeProxy.Host
   dotnet publish -c Release -o ./publish
   cd publish
   dotnet ClaudeCodeProxy.Host.dll

2. Frontend Build

   cd web
   npm run build
   # Serve the dist folder with your preferred web server

Create appsettings.json in the Host project:

{
  "ThorPlatformOptions": {
    "DatabaseConnectionString": "Data Source=claudecodeproxy.db",
    "JwtSettings": {
      "SecretKey": "your-secret-key-here",
      "Issuer": "ClaudeCodeProxy",
      "Audience": "ClaudeCodeProxy-Users",
      "ExpirationHours": 24
    }
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  }
}

Update web/src/config/api.ts:

export const API_CONFIG = {
  baseURL: process.env.VITE_API_URL || 'http://localhost:5000',
  timeout: 30000,
  retries: 3
};

Key Features:

• Live system performance indicators
• Cost tracking with trend analysis
• Token usage analytics (input/output/cache)
• API key status monitoring
• System uptime and health metrics

• Usage Heat Maps - Visual representation of API usage patterns
• Cost Flow Analysis - Detailed financial attribution and forecasting
• Performance Trends - Historical data with predictive insights
• User Profiling - Behavioral analysis and usage optimization

All API endpoints require JWT authentication:

# Login to get JWT token
curl -X POST "http://localhost:5000/api/auth/login" \
  -H "Content-Type: application/json" \
  -d '{"username":"admin","password":"password"}'

# Use token in subsequent requests
curl -H "Authorization: Bearer YOUR_JWT_TOKEN" \
  "http://localhost:5000/api/apikeys"

# Claude API Proxy
curl -X POST "http://localhost:5000/v1/messages" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"claude-3-sonnet","messages":[...]}'

# OpenAI API Proxy  
curl -X POST "http://localhost:5000/v1/chat/completions" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-4","messages":[...]}'

Claude OAuth Integration

OpenAI Full API Support

Gemini Project-based Auth

• Intelligent Routing - Automatic platform selection based on request parameters
• Model Mapping - Cross-platform model compatibility management
• Cost Calculation - Platform-specific pricing models and usage tracking
• Error Handling - Platform-specific error codes and retry logic

• Request/Response Tracking - Complete API transaction logging
• Token Usage Monitoring - Detailed input/output token calculation
• Cost Attribution - Real-time cost calculation and allocation
• Performance Metrics - Response time, throughput, and error rates

• Real-time status updates and system health monitoring
• Usage threshold alerts with automatic notifications
• Error tracking with immediate notification of system issues
• Capacity planning with proactive scaling recommendations

• 🔐 JWT Authentication - Secure token-based authentication with configurable expiration
• 🔒 Encrypted Storage - API keys encrypted at rest and in transit
• 🚦 Rate Limiting - Comprehensive throttling to prevent abuse
• 🌐 IP Restrictions - Client IP whitelisting for enhanced access control
• 📋 Audit Logging - Complete audit trails for compliance and security monitoring

{
  "SecurityRecommendations": {
    "JwtSecretKey": "Use a strong, randomly generated secret key (256+ bits)",
    "DatabaseEncryption": "Enable SQLite encryption in production environments",
    "TLS": "Always use HTTPS in production deployments",
    "RateLimiting": "Configure appropriate rate limits based on your usage patterns",
    "Monitoring": "Enable comprehensive logging and monitoring for security events"
  }
}

We welcome contributions! Please see our Contributing Guide for details.

1. Fork the repository
2. Create a feature branch (git checkout -b feature/AmazingFeature)
3. Commit your changes (git commit -m 'Add some AmazingFeature')
4. Push to the branch (git push origin feature/AmazingFeature)
5. Open a Pull Request

• Backend: Follow .NET coding conventions
• Frontend: ESLint + Prettier configuration included
• Commit Messages: Use Conventional Commits

This project is licensed under the MIT License - see the LICENSE file for details.

• Anthropic for Claude API
• OpenAI for GPT APIs
• Google for Gemini API
• Shadcn/ui for UI components
• Tailwind CSS for styling