fix for pulling config

marktayl1 · marktayl1 · commit 13f53bfae590 · 2025-04-30T11:29:01.000-07:00
diff --git a/src/backend/app_config.py b/src/backend/app_config.py
@@ -0,0 +1,277 @@
+# app_config.py
+import os
+import logging
+from typing import Optional, List, Dict, Any
+from dotenv import load_dotenv
+from azure.identity import DefaultAzureCredential, ClientSecretCredential
+from azure.cosmos.aio import CosmosClient
+from azure.ai.projects.aio import AIProjectClient
+from semantic_kernel.kernel import Kernel
+from semantic_kernel.contents import ChatHistory
+from semantic_kernel.agents.azure_ai.azure_ai_agent import AzureAIAgent
+from semantic_kernel.functions import KernelFunction
+
+# Load environment variables from .env file
+load_dotenv()
+
+
+class AppConfig:
+    """Application configuration class that loads settings from environment variables."""
+
+    def __init__(self):
+        """Initialize the application configuration with environment variables."""
+        # Azure authentication settings
+        self.AZURE_TENANT_ID = self._get_optional("AZURE_TENANT_ID")
+        self.AZURE_CLIENT_ID = self._get_optional("AZURE_CLIENT_ID")
+        self.AZURE_CLIENT_SECRET = self._get_optional("AZURE_CLIENT_SECRET")
+
+        # CosmosDB settings
+        self.COSMOSDB_ENDPOINT = self._get_optional("COSMOSDB_ENDPOINT")
+        self.COSMOSDB_DATABASE = self._get_optional("COSMOSDB_DATABASE")
+        self.COSMOSDB_CONTAINER = self._get_optional("COSMOSDB_CONTAINER")
+
+        # Azure OpenAI settings
+        self.AZURE_OPENAI_DEPLOYMENT_NAME = self._get_required(
+            "AZURE_OPENAI_DEPLOYMENT_NAME", "gpt-4o"
+        )
+        self.AZURE_OPENAI_API_VERSION = self._get_required(
+            "AZURE_OPENAI_API_VERSION", "2024-11-20"
+        )
+        self.AZURE_OPENAI_ENDPOINT = self._get_required("AZURE_OPENAI_ENDPOINT")
+        self.AZURE_OPENAI_SCOPES = [
+            f"{self._get_optional('AZURE_OPENAI_SCOPE', 'https://cognitiveservices.azure.com/.default')}"
+        ]
+
+        # Frontend settings
+        self.FRONTEND_SITE_NAME = self._get_optional(
+            "FRONTEND_SITE_NAME", "http://127.0.0.1:3000"
+        )
+
+        # Azure AI settings
+        self.AZURE_AI_SUBSCRIPTION_ID = self._get_required("AZURE_AI_SUBSCRIPTION_ID")
+        self.AZURE_AI_RESOURCE_GROUP = self._get_required("AZURE_AI_RESOURCE_GROUP")
+        self.AZURE_AI_PROJECT_NAME = self._get_required("AZURE_AI_PROJECT_NAME")
+        self.AZURE_AI_AGENT_PROJECT_CONNECTION_STRING = self._get_required(
+            "AZURE_AI_AGENT_PROJECT_CONNECTION_STRING"
+        )
+
+        # Cached clients and resources
+        self._azure_credentials = None
+        self._cosmos_client = None
+        self._cosmos_database = None
+        self._ai_project_client = None
+
+    def _get_required(self, name: str, default: Optional[str] = None) -> str:
+        """Get a required configuration value from environment variables.
+
+        Args:
+            name: The name of the environment variable
+            default: Optional default value if not found
+
+        Returns:
+            The value of the environment variable or default if provided
+
+        Raises:
+            ValueError: If the environment variable is not found and no default is provided
+        """
+        if name in os.environ:
+            return os.environ[name]
+        if default is not None:
+            logging.warning(
+                "Environment variable %s not found, using default value", name
+            )
+            return default
+        raise ValueError(
+            f"Environment variable {name} not found and no default provided"
+        )
+
+    def _get_optional(self, name: str, default: str = "") -> str:
+        """Get an optional configuration value from environment variables.
+
+        Args:
+            name: The name of the environment variable
+            default: Default value if not found (default: "")
+
+        Returns:
+            The value of the environment variable or the default value
+        """
+        if name in os.environ:
+            return os.environ[name]
+        return default
+
+    def _get_bool(self, name: str) -> bool:
+        """Get a boolean configuration value from environment variables.
+
+        Args:
+            name: The name of the environment variable
+
+        Returns:
+            True if the environment variable exists and is set to 'true' or '1', False otherwise
+        """
+        return name in os.environ and os.environ[name].lower() in ["true", "1"]
+
+    def get_azure_credentials(self):
+        """Get Azure credentials using DefaultAzureCredential.
+
+        Returns:
+            DefaultAzureCredential instance for Azure authentication
+        """
+        # Cache the credentials object
+        if self._azure_credentials is not None:
+            return self._azure_credentials
+
+        try:
+            self._azure_credentials = DefaultAzureCredential()
+            return self._azure_credentials
+        except Exception as exc:
+            logging.warning("Failed to create DefaultAzureCredential: %s", exc)
+            return None
+
+    def get_cosmos_database_client(self):
+        """Get a Cosmos DB client for the configured database.
+
+        Returns:
+            A Cosmos DB database client
+        """
+        try:
+            if self._cosmos_client is None:
+                self._cosmos_client = CosmosClient(
+                    self.COSMOSDB_ENDPOINT, credential=self.get_azure_credentials()
+                )
+
+            if self._cosmos_database is None:
+                self._cosmos_database = self._cosmos_client.get_database_client(
+                    self.COSMOSDB_DATABASE
+                )
+
+            return self._cosmos_database
+        except Exception as exc:
+            logging.error(
+                "Failed to create CosmosDB client: %s. CosmosDB is required for this application.",
+                exc,
+            )
+            raise
+
+    def create_kernel(self):
+        """Creates a new Semantic Kernel instance.
+
+        Returns:
+            A new Semantic Kernel instance
+        """
+        # Create a new kernel instance without manually configuring OpenAI services
+        # The agents will be created using Azure AI Agent Project pattern instead
+        kernel = Kernel()
+        return kernel
+
+    def get_ai_project_client(self):
+        """Create and return an AIProjectClient for Azure AI Foundry using from_connection_string.
+
+        Returns:
+            An AIProjectClient instance
+        """
+        if self._ai_project_client is not None:
+            return self._ai_project_client
+
+        try:
+            credential = self.get_azure_credentials()
+            if credential is None:
+                raise RuntimeError(
+                    "Unable to acquire Azure credentials; ensure DefaultAzureCredential is configured"
+                )
+
+            connection_string = self.AZURE_AI_AGENT_PROJECT_CONNECTION_STRING
+            self._ai_project_client = AIProjectClient.from_connection_string(
+                credential=credential, conn_str=connection_string
+            )
+            logging.info("Successfully created AIProjectClient using connection string")
+            return self._ai_project_client
+        except Exception as exc:
+            logging.error("Failed to create AIProjectClient: %s", exc)
+            raise
+
+    async def create_azure_ai_agent(
+        self,
+        kernel: Kernel,
+        agent_name: str,
+        instructions: str,
+        tools: Optional[List[KernelFunction]] = None,
+        response_format=None,
+        temperature: float = 0.0,
+    ):
+        """
+        Creates a new Azure AI Agent with the specified name and instructions using AIProjectClient.
+        If an agent with the given name (assistant_id) already exists, it tries to retrieve it first.
+
+        Args:
+            kernel: The Semantic Kernel instance
+            agent_name: The name of the agent (will be used as assistant_id)
+            instructions: The system message / instructions for the agent
+            agent_type: The type of agent (defaults to "assistant")
+            tools: Optional tool definitions for the agent
+            tool_resources: Optional tool resources required by the tools
+            response_format: Optional response format to control structured output
+            temperature: The temperature setting for the agent (defaults to 0.0)
+
+        Returns:
+            A new AzureAIAgent instance
+        """
+        try:
+            # Get the AIProjectClient
+            project_client = self.get_ai_project_client()
+
+            # First try to get an existing agent with this name as assistant_id
+            try:
+                logging.info(f"Trying to retrieve existing agent with ID: {agent_name}")
+                existing_definition = await project_client.agents.get_agent(agent_name)
+                logging.info(f"Found existing agent with ID: {agent_name}")
+
+                # Create the agent instance directly with project_client and existing definition
+                agent = AzureAIAgent(
+                    client=project_client,
+                    definition=existing_definition,
+                    kernel=kernel,
+                    plugins=tools,
+                )
+
+                logging.info(
+                    f"Successfully loaded existing Azure AI Agent for {agent_name}"
+                )
+                return agent
+            except Exception as e:
+                # The Azure AI Projects SDK throws an exception when the agent doesn't exist
+                # (not returning None), so we catch it and proceed to create a new agent
+                if "ResourceNotFound" in str(e) or "404" in str(e):
+                    logging.info(
+                        f"Agent with ID {agent_name} not found. Will create a new one."
+                    )
+                else:
+                    # Log unexpected errors but still try to create a new agent
+                    logging.warning(
+                        f"Unexpected error while retrieving agent {agent_name}: {str(e)}. Attempting to create new agent."
+                    )
+
+            # Create the agent using the project client with the agent_name as both name and assistantId
+            agent_definition = await project_client.agents.create_agent(
+                model=self.AZURE_OPENAI_DEPLOYMENT_NAME,
+                name=agent_name,
+                instructions=instructions,
+                temperature=temperature,
+                response_format=response_format,
+            )
+
+            # Create the agent instance directly with project_client and definition
+            agent = AzureAIAgent(
+                client=project_client,
+                definition=agent_definition,
+                kernel=kernel,
+                plugins=tools,
+            )
+
+            return agent
+        except Exception as exc:
+            logging.error("Failed to create Azure AI Agent: %s", exc)
+            raise
+
+
+# Create a global instance of AppConfig
+config = AppConfig()
diff --git a/src/backend/utils_kernel.py b/src/backend/utils_kernel.py
@@ -8,6 +8,9 @@
 
 # Semantic Kernel imports
 import semantic_kernel as sk
+
+# Import AppConfig from app_config
+from app_config import config
 from azure.identity import DefaultAzureCredential
 from context.cosmos_memory_kernel import CosmosMemoryContext
 
