making api not visible

app/llm.py

@@ -1,184 +1,181 @@
-import os
-import yaml
-import requests
-from decouple import config as decouple_config
-from datetime import datetime
-
-# For local LLM using transformers
-from transformers import AutoModelForCausalLM, AutoTokenizer
-import torch
-
-from google import genai
-from google.genai import types
-# Import the Groq client
-from groq import Groq
-
-class LLMProcessor:
-    def __init__(self):
-        """
-        Initialize the LLMProcessor by loading configuration and initializing all LLM clients.
-        """
-        # Compute the absolute path to the config file (located at <project_root>/config/config.yml)
-        base_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
-        config_path = os.path.join(base_dir, "config", "config.yml")
-        with open(config_path, "r") as file:
-            self.config_data = yaml.safe_load(file)
-        
-        # --- Groq Initialization ---
-        llm_config = self.config_data.get("llm", {})
-        # groq_config = llm_config.get("groq", {})
-        # self.groq_api_key = groq_config.get("api_key") or decouple_config("GROQ_API_KEY")
-        # self.groq_client = Groq(api_key=self.groq_api_key)
-        
-        # --- Gemini Initialization ---
-        gemini_config = llm_config.get("gemini", {})
-        self.gemini_api_key = gemini_config.get("api_key")
-        self.gemini_endpoint = gemini_config.get("endpoint")
-        if not (self.gemini_api_key and self.gemini_endpoint):
-            print("Warning: Gemini API configuration is incomplete.")
-        
-        # # --- Huggingface Initialization ---
-        # hf_config = llm_config.get("huggingface", {})
-        # self.hf_api_token = hf_config.get("api_token")
-        # if not self.hf_api_token:
-        #     print("Warning: Huggingface API token is missing in configuration.")
-        
-        # # --- Local LLM Initialization ---
-        # local_config = llm_config.get("local", {})
-        # self.local_model_name = local_config.get("default_model")
-        # if self.local_model_name:
-        #     print(f"Loading local model: {self.local_model_name}...")
-        #     self.local_tokenizer = AutoTokenizer.from_pretrained(self.local_model_name)
-        #     self.local_model = AutoModelForCausalLM.from_pretrained(self.local_model_name)
-        #     # Optional: set the model to evaluation mode
-        #     self.local_model.eval()
-        # else:
-        #     print("Warning: No default local model specified in configuration.")
-
-    def call_groq_llm(self, model, message, token_limit=512, temperature=0.7):
-        """
-        Call the Groq LLM API with a token limit and temperature.
-
-        Parameters:
-            model (str): The model name to use.
-            message (str): The input message.
-            token_limit (int): Maximum number of tokens to generate. (default: 1024)
-            temperature (float): Temperature parameter for generation. (default: 0.7)
-
-        Returns:
-            The API response.
-        """
-        response = self.groq_client.llm.generate(model=model, message=message,max_tokens=token_limit, temperature=temperature)
-        return response
-
-    def call_gemini_llm(self, model, message, token_limit=400, temperature=0.6):
-        """
-        Call the Google Gemini LLM API with a token limit and temperature.
-        
-        Parameters:
-            model (str): The Gemini model to use.
-            message (str): The input message.
-            token_limit (int): Maximum number of tokens to generate (default: 512).
-            temperature (float): Temperature for generation (default: 0.7).
-        
-        Returns:
-            The API response as JSON/dict.
-        """
-        sys_instruct = """You are a Cancer doctor who is an expert in the field of oncology. You are very knowledgeable and can answer any question related to cancer. You are also a great teacher and can explain complex concepts in simple terms. You are very patient and understanding, and you always take the time to listen to your patients' concerns. You are also very compassionate and empathetic, and you always put your patients' needs first. and make it short and straight to the point and take the data from the context"""
-        if not (self.gemini_api_key and self.gemini_endpoint):
-            raise Exception("Gemini API configuration is missing.")
-        client = genai.Client(api_key=self.gemini_api_key)
-        try:
-            response = client.models.generate_content(
-                model=model,
-                config=types.GenerateContentConfig(
-                    system_instruction=sys_instruct,
-                    max_output_tokens=token_limit,
-                    temperature=temperature
-                ),
-                contents=[message]
-            )
-            return response.text
-        except Exception as e:
-            raise Exception(f"Gemini API error: {response.status_code} {response.text}")
-
-    def call_huggingface_llm(self, model_path, message):
-        """
-        Call the Huggingface Inference API.
-        
-        Parameters:
-            model_path (str): The Huggingface model identifier or path.
-            message (str): The input message.
-        
-        Returns:
-            The API response as JSON.
-        """
-        if not self.hf_api_token:
-            raise Exception("Huggingface API token is missing in configuration.")
-        hf_endpoint = f"https://api-inference.huggingface.co/models/{model_path}"
-        headers = {"Authorization": f"Bearer {self.hf_api_token}"}
-        payload = {"inputs": message}
-        response = requests.post(hf_endpoint, json=payload, headers=headers)
-        if response.status_code == 200:
-            return response.json()
-        else:
-            raise Exception(f"Huggingface API error: {response.status_code} {response.text}")
-
-    def call_local_llm(self, model_name, message):
-        """
-        Call a local LLM using the Transformers library.
-        
-        Parameters:
-            model_name (str): The local model name or path (if different from the default).
-            message (str): The input message.
-        
-        Returns:
-            The generated text.
-        """
-        # Use the preloaded local model if the model_name matches the default.
-        if model_name == self.local_model_name:
-            tokenizer = self.local_tokenizer
-            model = self.local_model
-        else:
-            # Load a new model if different from the default.
-            tokenizer = AutoTokenizer.from_pretrained(model_name)
-            model = AutoModelForCausalLM.from_pretrained(model_name)
-            model.eval()
-        
-        inputs = tokenizer(message, return_tensors="pt")
-        # Optionally, use model.generate with parameters (e.g., max_length, temperature)
-        outputs = model.generate(**inputs)
-        generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
-        return generated_text
-
-# # Example usage:
-# if __name__ == "__main__":
-#     llm_processor = LLMProcessor()
-    
-#     # Groq API call example.
-#     try:
-#         groq_response = llm_processor.call_groq_llm("whisper-large-v3-turbo", "Hello, how are you?")
-#         print("Groq response:", groq_response)
-#     except Exception as e:
-#         print("Groq error:", e)
-    
-#     # Gemini API call example.
-#     try:
-#         gemini_response = llm_processor.call_gemini_llm("gemini-model", "Hello, how are you?")
-#         print("Gemini response:", gemini_response)
-#     except Exception as e:
-#         print("Gemini error:", e)
-    
-#     # Huggingface API call example.
-#     try:
-#         hf_response = llm_processor.call_huggingface_llm("gpt2", "Hello, how are you?")
-#         print("Huggingface response:", hf_response)
-#     except Exception as e:
-#         print("Huggingface error:", e)
-    
-#     # Local LLM call example.
-#     try:
-#         local_response = llm_processor.call_local_llm(llm_processor.local_model_name, "Hello, how are you?")
-#         print("Local LLM response:", local_response)
-#     except Exception as e:
-#         print("Local LLM error:", e)
+import os
+import yaml
+import requests
+from decouple import config as decouple_config
+from datetime import datetime
+
+# For local LLM using transformers
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+
+from google import genai
+from google.genai import types
+# Import the Groq client
+from groq import Groq
+
+class LLMProcessor:
+    def __init__(self):
+        """
+        Initialize the LLMProcessor by loading configuration and initializing all LLM clients.
+        """
+        # Compute the absolute path to the config file (located at <project_root>/config/config.yml)
+        base_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+        config_path = os.path.join(base_dir, "config", "config.yml")
+        with open(config_path, "r") as file:
+            self.config_data = yaml.safe_load(file)
+        
+        # --- Gemini Initialization ---
+        gemini_config = llm_config.get("gemini", {})
+        self.gemini_api_key = os.getenv("GEMINI_API_KEY")  # From Hugging Face secrets
+        self.gemini_endpoint = gemini_config.get("endpoint")
+        
+        if not self.gemini_api_key:
+            print("Error: Gemini API key not found in environment variables")
+        if not self.gemini_endpoint:
+            print("Warning: Gemini endpoint not configured")
+        
+        # # --- Huggingface Initialization ---
+        # hf_config = llm_config.get("huggingface", {})
+        # self.hf_api_token = hf_config.get("api_token")
+        # if not self.hf_api_token:
+        #     print("Warning: Huggingface API token is missing in configuration.")
+        
+        # # --- Local LLM Initialization ---
+        # local_config = llm_config.get("local", {})
+        # self.local_model_name = local_config.get("default_model")
+        # if self.local_model_name:
+        #     print(f"Loading local model: {self.local_model_name}...")
+        #     self.local_tokenizer = AutoTokenizer.from_pretrained(self.local_model_name)
+        #     self.local_model = AutoModelForCausalLM.from_pretrained(self.local_model_name)
+        #     # Optional: set the model to evaluation mode
+        #     self.local_model.eval()
+        # else:
+        #     print("Warning: No default local model specified in configuration.")
+
+    def call_groq_llm(self, model, message, token_limit=512, temperature=0.7):
+        """
+        Call the Groq LLM API with a token limit and temperature.
+
+        Parameters:
+            model (str): The model name to use.
+            message (str): The input message.
+            token_limit (int): Maximum number of tokens to generate. (default: 1024)
+            temperature (float): Temperature parameter for generation. (default: 0.7)
+
+        Returns:
+            The API response.
+        """
+        response = self.groq_client.llm.generate(model=model, message=message,max_tokens=token_limit, temperature=temperature)
+        return response
+
+    def call_gemini_llm(self, model, message, token_limit=400, temperature=0.6):
+        """
+        Call the Google Gemini LLM API with a token limit and temperature.
+        
+        Parameters:
+            model (str): The Gemini model to use.
+            message (str): The input message.
+            token_limit (int): Maximum number of tokens to generate (default: 512).
+            temperature (float): Temperature for generation (default: 0.7).
+        
+        Returns:
+            The API response as JSON/dict.
+        """
+        sys_instruct = """You are a Cancer doctor who is an expert in the field of oncology. You are very knowledgeable and can answer any question related to cancer. You are also a great teacher and can explain complex concepts in simple terms. You are very patient and understanding, and you always take the time to listen to your patients' concerns. You are also very compassionate and empathetic, and you always put your patients' needs first. and make it short and straight to the point and take the data from the context"""
+        if not (self.gemini_api_key and self.gemini_endpoint):
+            raise Exception("Gemini API configuration is missing.")
+        client = genai.Client(api_key=self.gemini_api_key)
+        try:
+            response = client.models.generate_content(
+                model=model,
+                config=types.GenerateContentConfig(
+                    system_instruction=sys_instruct,
+                    max_output_tokens=token_limit,
+                    temperature=temperature
+                ),
+                contents=[message]
+            )
+            return response.text
+        except Exception as e:
+            raise Exception(f"Gemini API error: {response.status_code} {response.text}")
+
+    def call_huggingface_llm(self, model_path, message):
+        """
+        Call the Huggingface Inference API.
+        
+        Parameters:
+            model_path (str): The Huggingface model identifier or path.
+            message (str): The input message.
+        
+        Returns:
+            The API response as JSON.
+        """
+        if not self.hf_api_token:
+            raise Exception("Huggingface API token is missing in configuration.")
+        hf_endpoint = f"https://api-inference.huggingface.co/models/{model_path}"
+        headers = {"Authorization": f"Bearer {self.hf_api_token}"}
+        payload = {"inputs": message}
+        response = requests.post(hf_endpoint, json=payload, headers=headers)
+        if response.status_code == 200:
+            return response.json()
+        else:
+            raise Exception(f"Huggingface API error: {response.status_code} {response.text}")
+
+    def call_local_llm(self, model_name, message):
+        """
+        Call a local LLM using the Transformers library.
+        
+        Parameters:
+            model_name (str): The local model name or path (if different from the default).
+            message (str): The input message.
+        
+        Returns:
+            The generated text.
+        """
+        # Use the preloaded local model if the model_name matches the default.
+        if model_name == self.local_model_name:
+            tokenizer = self.local_tokenizer
+            model = self.local_model
+        else:
+            # Load a new model if different from the default.
+            tokenizer = AutoTokenizer.from_pretrained(model_name)
+            model = AutoModelForCausalLM.from_pretrained(model_name)
+            model.eval()
+        
+        inputs = tokenizer(message, return_tensors="pt")
+        # Optionally, use model.generate with parameters (e.g., max_length, temperature)
+        outputs = model.generate(**inputs)
+        generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        return generated_text
+
+# # Example usage:
+# if __name__ == "__main__":
+#     llm_processor = LLMProcessor()
+    
+#     # Groq API call example.
+#     try:
+#         groq_response = llm_processor.call_groq_llm("whisper-large-v3-turbo", "Hello, how are you?")
+#         print("Groq response:", groq_response)
+#     except Exception as e:
+#         print("Groq error:", e)
+    
+#     # Gemini API call example.
+#     try:
+#         gemini_response = llm_processor.call_gemini_llm("gemini-model", "Hello, how are you?")
+#         print("Gemini response:", gemini_response)
+#     except Exception as e:
+#         print("Gemini error:", e)
+    
+#     # Huggingface API call example.
+#     try:
+#         hf_response = llm_processor.call_huggingface_llm("gpt2", "Hello, how are you?")
+#         print("Huggingface response:", hf_response)
+#     except Exception as e:
+#         print("Huggingface error:", e)
+    
+#     # Local LLM call example.
+#     try:
+#         local_response = llm_processor.call_local_llm(llm_processor.local_model_name, "Hello, how are you?")
+#         print("Local LLM response:", local_response)
+#     except Exception as e:
+#         print("Local LLM error:", e)