130 lines
4.0 KiB
Rust
130 lines
4.0 KiB
Rust
use anyhow::Result;
|
|
use axum::{Router, routing::get};
|
|
use std::net::SocketAddr;
|
|
use std::sync::Arc;
|
|
use tracing::{info, error};
|
|
|
|
use llm_proxy::{
|
|
config::AppConfig,
|
|
state::AppState,
|
|
providers::{
|
|
ProviderManager,
|
|
openai::OpenAIProvider,
|
|
gemini::GeminiProvider,
|
|
deepseek::DeepSeekProvider,
|
|
grok::GrokProvider,
|
|
},
|
|
database,
|
|
server,
|
|
dashboard,
|
|
rate_limiting::{RateLimitManager, RateLimiterConfig, CircuitBreakerConfig},
|
|
};
|
|
|
|
#[tokio::main]
|
|
async fn main() -> Result<()> {
|
|
// Initialize tracing (logging)
|
|
tracing_subscriber::fmt()
|
|
.with_max_level(tracing::Level::INFO)
|
|
.with_target(false)
|
|
.init();
|
|
|
|
info!("Starting LLM Proxy Gateway v{}", env!("CARGO_PKG_VERSION"));
|
|
|
|
// Load configuration
|
|
let config = AppConfig::load().await?;
|
|
info!("Configuration loaded from {:?}", config.config_path);
|
|
|
|
// Initialize database connection pool
|
|
let db_pool = database::init(&config.database).await?;
|
|
info!("Database initialized at {:?}", config.database.path);
|
|
|
|
// Initialize provider manager with configured providers
|
|
let mut provider_manager = ProviderManager::new();
|
|
|
|
// Initialize OpenAI
|
|
if config.providers.openai.enabled {
|
|
match OpenAIProvider::new(&config.providers.openai, &config) {
|
|
Ok(p) => {
|
|
provider_manager.add_provider(Arc::new(p));
|
|
info!("OpenAI provider initialized");
|
|
}
|
|
Err(e) => error!("Failed to initialize OpenAI provider: {}", e),
|
|
}
|
|
}
|
|
|
|
// Initialize Gemini
|
|
if config.providers.gemini.enabled {
|
|
match GeminiProvider::new(&config.providers.gemini, &config) {
|
|
Ok(p) => {
|
|
provider_manager.add_provider(Arc::new(p));
|
|
info!("Gemini provider initialized");
|
|
}
|
|
Err(e) => error!("Failed to initialize Gemini provider: {}", e),
|
|
}
|
|
}
|
|
|
|
// Initialize DeepSeek
|
|
if config.providers.deepseek.enabled {
|
|
match DeepSeekProvider::new(&config.providers.deepseek, &config) {
|
|
Ok(p) => {
|
|
provider_manager.add_provider(Arc::new(p));
|
|
info!("DeepSeek provider initialized");
|
|
}
|
|
Err(e) => error!("Failed to initialize DeepSeek provider: {}", e),
|
|
}
|
|
}
|
|
|
|
// Initialize Grok
|
|
if config.providers.grok.enabled {
|
|
match GrokProvider::new(&config.providers.grok, &config) {
|
|
Ok(p) => {
|
|
provider_manager.add_provider(Arc::new(p));
|
|
info!("Grok provider initialized");
|
|
}
|
|
Err(e) => error!("Failed to initialize Grok provider: {}", e),
|
|
}
|
|
}
|
|
|
|
// Create rate limit manager
|
|
let rate_limit_manager = RateLimitManager::new(
|
|
RateLimiterConfig::default(),
|
|
CircuitBreakerConfig::default(),
|
|
);
|
|
|
|
// Fetch model registry from models.dev
|
|
let model_registry = match llm_proxy::utils::registry::fetch_registry().await {
|
|
Ok(registry) => registry,
|
|
Err(e) => {
|
|
error!("Failed to fetch model registry: {}. Using empty registry.", e);
|
|
llm_proxy::models::registry::ModelRegistry { providers: std::collections::HashMap::new() }
|
|
}
|
|
};
|
|
|
|
// Create application state
|
|
let state = AppState::new(provider_manager, db_pool, rate_limit_manager, model_registry);
|
|
|
|
// Create application router
|
|
let app = Router::new()
|
|
.route("/health", get(health_check))
|
|
.route("/", get(root))
|
|
.merge(server::router(state.clone()))
|
|
.merge(dashboard::router(state.clone()));
|
|
|
|
// Start server
|
|
let addr = SocketAddr::from(([0, 0, 0, 0], config.server.port));
|
|
info!("Server listening on http://{}", addr);
|
|
|
|
let listener = tokio::net::TcpListener::bind(&addr).await?;
|
|
axum::serve(listener, app).await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn health_check() -> &'static str {
|
|
"OK"
|
|
}
|
|
|
|
async fn root() -> &'static str {
|
|
"LLM Proxy Gateway - Unified interface for OpenAI, Gemini, DeepSeek, and Grok"
|
|
}
|