(feat) Azure Support (#36)

* azure support e2e

* fixed error

Author: danwritecode

.env.example

@@ -1,9 +1,14 @@
 ## Backend environment variables ##
 RUST_LOG=info
-OPENROUTER_API_KEY=
 JWT_SECRET=
 USE_SECURE_COOKIE=false # Set to true to use secure cookies
 
+## Provider API Keys ##
+# Only set the API keys for providers you plan to use
+OPENROUTER_API_KEY=
+OPENAI_API_KEY=
+AZURE_API_KEY=
+
 # If running locally, select path on local machine
 #DATABASE_URL=sqlite:/home/user/development/llmkit/backend/llmkit.db
 

README.md

@@ -60,12 +60,35 @@ Our mission is to make prompt crafting dynamic, prompt management safe, and prom
 Llmkit supports the following LLM providers:
 
 - **OpenRouter**: Access to 100+ models through a unified API
-- **OpenAI**: Direct integration with OpenAI's GPT models
+- **OpenAI**: Direct integration with OpenAI's GPT models  
+- **Azure OpenAI**: Microsoft's Azure-hosted OpenAI models
 - **Anthropic**: Claude models (coming soon)
-- **Azure OpenAI**: Microsoft's Azure-hosted OpenAI models (coming soon)
 - **Google Gemini**: Google's Gemini models (coming soon)
 - **DeepSeek**: DeepSeek's models (coming soon)
 
+### Provider Configuration
+
+Providers need to be configured before they can be used. Each provider requires:
+1. An API key set as an environment variable (see `.env.example` for all required variables)
+2. A base URL configuration (some providers have default URLs, Azure requires manual configuration)
+
+To configure providers:
+1. Navigate to the **Providers** page in the UI
+2. Click "Configure" on the provider you want to set up
+3. Enter the base URL if required (especially for Azure)
+4. Providers will show as "Available" when both API key and base URL are configured
+
+### Azure OpenAI Setup
+
+Azure OpenAI requires additional configuration:
+
+1. **Set the API Key**: Add `AZURE_API_KEY=your_azure_api_key` to your `.env` file
+2. **Configure Base URL**: In the Providers page, set your Azure endpoint (e.g., `https://your-resource.openai.azure.com/`)
+3. **Model Configuration**: When adding Azure models:
+   - Enter your deployment name (not the full model name)
+   - Specify the API version (e.g., `2024-08-01-preview`)
+   - These will be automatically combined in the format: `deployment_name|api_version`
+
 ## How It Works
 
 ### Prompt Architecture
@@ -191,9 +214,7 @@ Every LLM call has a detailed trace that you can view. directly in the llmkit UI
 ### Required
 
 - **Rust Toolchain**: Latest stable version of Rust and Cargo
-- **API Keys**: You need API keys for the providers you want to use:
-  - **OpenRouter**: Required if using OpenRouter provider
-  - **OpenAI**: Required if using OpenAI or OpenRouter provider (set via `OPENAI_API_KEY`)
+- **API Keys**: You need API keys for the providers you want to use (see `.env.example`)
 - **SQLite**: For database functionality
 
 ### Optional Dependencies
@@ -229,7 +250,8 @@ USE_SECURE_COOKIE=false  # Set to true for HTTPS deployments
 
 # Provider API Keys (add the ones you need)
 OPENROUTER_API_KEY=your_openrouter_key_here
-OPENAI_API_KEY=your_openai_key_here  # Required for OpenAI and OpenRouter providers
+OPENAI_API_KEY=your_openai_key_here
+AZURE_API_KEY=your_azure_key_here
 ```
 
 4. Build and start the containers:
@@ -262,7 +284,7 @@ OPENROUTER_API_KEY=your_openrouter_key_here
 OPENAI_API_KEY=your_openai_key_here  # Required for OpenAI and OpenRouter providers
 ```
 
-**Note**: If you don't set the required API keys for a provider, the backend will fail when you try to use that provider.
+**Note**: Providers will show as "Not Available" in the UI if their API keys are not set. You can check provider status and configure base URLs on the Providers page.
 
 3. Start the server:
 ```bash

backend/migrations/20250606000000_azure_provider_support.sql

@@ -0,0 +1,10 @@
+-- SQLite workaround: drop and recreate column to make it nullable
+ALTER TABLE provider DROP COLUMN base_url;
+ALTER TABLE provider ADD COLUMN base_url TEXT;
+
+-- Update existing providers with their base URLs
+UPDATE provider SET base_url = 'https://openrouter.ai/api/v1' WHERE name = 'openrouter';
+UPDATE provider SET base_url = 'https://api.openai.com/v1' WHERE name = 'openai';
+
+-- Add Azure provider with null base_url (requires user configuration)
+INSERT INTO provider (name, base_url) VALUES ('azure', NULL);

backend/src/common/types/models.rs

@@ -4,19 +4,20 @@ use serde::Serialize;
 pub enum LlmApiProvider {
     Openrouter,
     OpenAi,
+    Azure,
 
     // TODO: Will support in future with more refined SDK
     // Anthropic,
     // Gemini,
     // Deepseek,
-    // Azure,
 }
 
 impl From<String> for LlmApiProvider {
     fn from(value: String) -> Self {
         match value.as_str() {
             "openrouter" => LlmApiProvider::Openrouter,
             "openai" => LlmApiProvider::OpenAi,
+            "azure" => LlmApiProvider::Azure,
             _ => unreachable!("Invalid Provider"),
         }
     }
@@ -27,6 +28,7 @@ impl From<LlmApiProvider> for String {
         match value {
             LlmApiProvider::Openrouter => "openrouter".to_string(),
             LlmApiProvider::OpenAi => "openai".to_string(),
+            LlmApiProvider::Azure => "azure".to_string(),
         }
     }
 }

backend/src/controllers/providers.rs

@@ -1,14 +1,45 @@
 use axum::{
-    extract::State,
+    extract::{Path, State},
     Json,
 };
 
-use super::types::response::providers::ProviderResponse;
+use super::types::{
+    request::providers::UpdateProviderRequest,
+    response::providers::ProviderResponse,
+};
 use crate::{AppError, AppState};
 
 pub async fn list_providers(
     State(state): State<AppState>,
 ) -> Result<Json<Vec<ProviderResponse>>, AppError> {
     let providers = state.db.provider.list_providers().await?;
-    Ok(Json(providers.into_iter().map(|p| p.into()).collect()))
+    
+    let provider_responses: Vec<ProviderResponse> = providers
+        .into_iter()
+        .map(|p| {
+            let mut response: ProviderResponse = p.into();
+            
+            // Check if API key exists in environment variables and base_url is configured
+            let api_key_exists = match response.name.as_str() {
+                "openai" => std::env::var("OPENAI_API_KEY").is_ok(),
+                "openrouter" => std::env::var("OPENROUTER_API_KEY").is_ok(),
+                "azure" => std::env::var("AZURE_API_KEY").is_ok(),
+                _ => false,
+            };
+            
+            response.is_available = api_key_exists && response.base_url.is_some();
+            response
+        })
+        .collect();
+    
+    Ok(Json(provider_responses))
+}
+
+pub async fn update_provider(
+    State(state): State<AppState>,
+    Path(id): Path<i32>,
+    Json(payload): Json<UpdateProviderRequest>,
+) -> Result<Json<ProviderResponse>, AppError> {
+    let provider = state.db.provider.update_provider(id, payload.base_url).await?;
+    Ok(Json(provider.into()))
 }

backend/src/controllers/types/request/mod.rs

@@ -2,6 +2,7 @@ pub mod models;
 pub mod prompts;
 pub mod prompt_eval;
 pub mod prompt_eval_run;
+pub mod providers;
 pub mod schema;
 pub mod user;
 pub mod tools;

backend/src/controllers/types/request/providers.rs

@@ -0,0 +1,6 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct UpdateProviderRequest {
+    pub base_url: Option<String>,
+}

backend/src/controllers/types/response/models.rs

@@ -8,7 +8,7 @@ pub struct ModelResponse {
     pub provider_id: i64,
     pub name: String,
     pub provider_name: String,
-    pub provider_base_url: String,
+    pub provider_base_url: Option<String>,
     pub supports_json: bool,
     pub supports_json_schema: bool,
     pub supports_tools: bool,

backend/src/controllers/types/response/providers.rs

@@ -6,15 +6,17 @@ use crate::db::types::providers::ProviderRow;
 pub struct ProviderResponse {
     pub id: i64,
     pub name: String,
-    pub base_url: String,
+    pub base_url: Option<String>,
+    pub is_available: bool,
 }
 
 impl From<ProviderRow> for ProviderResponse {
     fn from(row: ProviderRow) -> Self {
         Self {
             id: row.id,
-            name: row.name,
+            name: row.name.clone(),
             base_url: row.base_url,
+            is_available: false, // This will be set in the controller
         }
     }
 }

backend/src/db/providers.rs

@@ -66,4 +66,21 @@ impl ProviderRepository {
         .await?;
         Ok(provider)
     }
+
+    pub async fn update_provider(&self, id: i32, base_url: Option<String>) -> Result<ProviderRow> {
+        let provider = sqlx::query_as!(
+            ProviderRow,
+            r#"
+            UPDATE provider
+            SET base_url = ?
+            WHERE id = ?
+            RETURNING id, name, base_url, created_at
+            "#,
+            base_url,
+            id
+        )
+        .fetch_one(&self.pool)
+        .await?;
+        Ok(provider)
+    }
 }