diff --git a/src/bootstrap/mod.rs b/src/bootstrap/mod.rs
index f37244ae..5c7184c1 100644
--- a/src/bootstrap/mod.rs
+++ b/src/bootstrap/mod.rs
@@ -63,7 +63,6 @@ impl BootstrapManager {
         Ok(())
     }
 
-
     fn generate_secure_password(&self, length: usize) -> String {
         let mut rng = rand::rng();
         (0..length)
@@ -75,60 +74,27 @@ impl BootstrapManager {
     }
 
     pub async fn bootstrap(&mut self) {
-        if let Ok(tables_server) = std::env::var("TABLES_SERVER") {
-            if !tables_server.is_empty() {
-                info!(
-                    "Legacy mode detected (TABLES_SERVER present), skipping bootstrap installation"
-                );
-                let _database_url = std::env::var("DATABASE_URL").unwrap_or_else(|_| {
-                    let username =
-                        std::env::var("TABLES_USERNAME").unwrap_or_else(|_| "gbuser".to_string());
-                    let password =
-                        std::env::var("TABLES_PASSWORD").unwrap_or_else(|_| "postgres".to_string());
-                    let server =
-                        std::env::var("TABLES_SERVER").unwrap_or_else(|_| "localhost".to_string());
-                    let port = std::env::var("TABLES_PORT").unwrap_or_else(|_| "5432".to_string());
-                    let database =
-                        std::env::var("TABLES_DATABASE").unwrap_or_else(|_| "gbserver".to_string());
-                    format!(
-                        "postgres://{}:{}@{}:{}/{}",
-                        username, password, server, port, database
-                    )
-                });
-                match establish_pg_connection() {
-                    Ok(mut conn) => {
-                        if let Err(e) = self.apply_migrations(&mut conn) {
-                            log::warn!("Failed to apply migrations: {}", e);
-                        }
-                    }
-                    Err(e) => {
-                        log::warn!("Failed to connect to database: {}", e);
-                    }
-                }
-            }
-        } else {
-            let db_env_path = std::env::current_dir().unwrap().join(".env");
-            let db_password = self.generate_secure_password(32);
-            let database_url = std::env::var("DATABASE_URL").unwrap_or_else(|_| {
-                format!("postgres://gbuser:{}@localhost:5432/botserver", db_password)
-            });
-            let db_line = format!("DATABASE_URL={}\n", database_url);
-            let drive_password = self.generate_secure_password(16);
-            let drive_user = "gbdriveuser".to_string();
+        let db_env_path = std::env::current_dir().unwrap().join(".env");
+        let db_password = self.generate_secure_password(32);
+        let database_url = std::env::var("DATABASE_URL").unwrap_or_else(|_| {
+            format!("postgres://gbuser:{}@localhost:5432/botserver", db_password)
+        });
+        let db_line = format!("DATABASE_URL={}\n", database_url);
+        let drive_password = self.generate_secure_password(16);
+        let drive_user = "gbdriveuser".to_string();
 
-            let env_path = std::env::current_dir().unwrap().join(".env");
-            let env_content = format!(
-                "\nDRIVE_SERVER=http://localhost:9000\nDRIVE_ACCESSKEY={}\nDRIVE_SECRET={}\n",
-                drive_user, drive_password
-            );
-            let _ = std::fs::OpenOptions::new()
-                .create(true)
-                .append(true)
-                .open(&env_path)
-                .and_then(|mut file| std::io::Write::write_all(&mut file, env_content.as_bytes()));
+        let env_path = std::env::current_dir().unwrap().join(".env");
+        let env_content = format!(
+            "\nDRIVE_SERVER=http://localhost:9000\nDRIVE_ACCESSKEY={}\nDRIVE_SECRET={}\n",
+            drive_user, drive_password
+        );
+        let _ = std::fs::OpenOptions::new()
+            .create(true)
+            .append(true)
+            .open(&env_path)
+            .and_then(|mut file| std::io::Write::write_all(&mut file, env_content.as_bytes()));
 
-            let _ = std::fs::write(&db_env_path, db_line);
-        }
+        let _ = std::fs::write(&db_env_path, db_line);
 
         let pm = PackageManager::new(self.install_mode.clone(), self.tenant.clone()).unwrap();
         let required_components = vec!["tables", "drive", "cache", "llm"];
diff --git a/src/drive_monitor/mod.rs b/src/drive_monitor/mod.rs
index b53cd41b..21a9bd02 100644
--- a/src/drive_monitor/mod.rs
+++ b/src/drive_monitor/mod.rs
@@ -240,15 +240,15 @@ impl DriveMonitor {
         Ok(())
     }
     async fn compile_tool(&self, client: &Client, file_path: &str) -> Result<(), Box<dyn Error + Send + Sync>> {
-        info!("Fetching object from S3: bucket={}, key={}", &self.bucket_name, file_path);
+        info!("Fetching object from Drive: bucket={}, key={}", &self.bucket_name, file_path);
         let response = match client.get_object().bucket(&self.bucket_name).key(file_path).send().await {
             Ok(res) => {
-                info!("Successfully fetched object from S3: bucket={}, key={}, size={}", 
+                info!("Successfully fetched object from Drive: bucket={}, key={}, size={}", 
                     &self.bucket_name, file_path, res.content_length().unwrap_or(0));
                 res
             }
             Err(e) => {
-                log::error!("Failed to fetch object from S3: bucket={}, key={}, error={:?}", 
+                log::error!("Failed to fetch object from Drive: bucket={}, key={}, error={:?}", 
                     &self.bucket_name, file_path, e);
                 return Err(e.into());
             }
diff --git a/src/llm/local.rs b/src/llm/local.rs
index 69a00d9f..9486c61e 100644
--- a/src/llm/local.rs
+++ b/src/llm/local.rs
@@ -54,7 +54,7 @@ let (_default_bot_id, llm_url, llm_model, embedding_url, embedding_model, llm_se
     info!("Restarting any existing llama-server processes...");
     if let Err(e) = tokio::process::Command::new("sh")
         .arg("-c")
-        .arg("pkill -f llama-server || true")
+        .arg("pkill llama-server -9 || true")
         .spawn()
     {
         error!("Failed to execute pkill for llama-server: {}", e);
diff --git a/src/main.rs b/src/main.rs
index 865e1b1f..90d34ad6 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -229,7 +229,6 @@ async fn main() -> std::io::Result<()> {
         }
     };
     let cache_url = std::env::var("CACHE_URL")
-        .or_else(|_| std::env::var("REDIS_URL"))
         .unwrap_or_else(|_| "redis://localhost:6379".to_string());
     let redis_client = match redis::Client::open(cache_url.as_str()) {
         Ok(client) => Some(Arc::new(client)),