created config and config loader

.env.example

@@ -0,0 +1,16 @@
+# Core API Keys
+TAVILY_API_KEY=your-tavily-key
+OPENAI_API_KEY=your-openai-key
+GOOGLE_API_KEY=your-google-key
+
+# Huggingface SpaceID - if you want run and submit the answers outside of the HF space
+SPACE_ID=your-huggingface-space
+HF_TOKEN=your-huggingface-token
+
+# If running on Windows, configure the
+CHESS_ENGINE_PATH=stock-fish-engine-location-here
+
+# Configure this if you want to enable observability with LangSmith
+LANGSMITH_API_KEY=your-langsmith-key
+LANGSMITH_TRACING=true
+LANGSMITH_PROJECT=gaia_agent

config/settings.py

@@ -1,32 +1,161 @@
-# Configuration management
-
 import os
-from typing import Dict, Any
 from pathlib import Path
+from typing import Dict, List, Optional
+
+from dotenv import load_dotenv, find_dotenv
+from pydantic_settings import BaseSettings
+
+
+class AgentConfig(BaseSettings):
+    """
+    Configuration class that works with environment variable manager.
+    """
+
+    # Core settings
+    environment: str = "development"
+    agent_name: str = "gaia_agent"
+    debug: bool = False
+
+    # Model configuration
+    model_name: str = "gpt-4.1"
+    response_processing_model_name: str = "gpt-4.1-mini"
+
+    max_tokens: int = 20000
+
+    project_root: Path = Path(__file__).parent.parent
+    prompts_location: Path = project_root / "config" / "prompts.yaml"
 
+    class Config:
+        env_file = ".env"
+        case_sensitive = False
+        extra = "allow"
 
-class AgentConfig:
-    """Centralized configuration"""
 
-    def __init__(self):
-        # LLM Configuration
-        self.MODEL_NAME = os.getenv("MODEL_NAME", "gpt-4.1")
+class EnvironmentVariableManager:
+    """
+    Manages loading .env files and setting environment variables that
+    third-party libraries expect to find.
+    """
 
-        #Sizing limitations
-        self.MAX_CONTEXT_TOKENS = 20000
+    def __init__(self, env_file: Optional[str] = None):
+        """
+        Initialize the environment variable manager.
 
+        Args:
+            env_file: Path to .env file (if None, will search for it)
+        """
+        self.env_file = env_file or find_dotenv()
+        self.loaded_vars = {}
 
-        # File Paths
-        self.PROJECT_ROOT = Path(__file__).parent.parent
-        self.PROMPTS_PATH = self.PROJECT_ROOT / "config" / "prompts.yaml"
+    def load_env_file(self) -> Dict[str, str]:
+        """Load the .env file and return all variables."""
+        if not self.env_file or not Path(self.env_file).exists():
+            print(f"Warning: .env file not found at {self.env_file}")
+            return {}
 
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert config to dictionary"""
-        return {
-            key: value for key, value in self.__dict__.items()
-            if not key.startswith('_')
+        # Load .env file
+        load_dotenv(self.env_file, override=True)
+
+        # Read the file manually to get all variables
+        env_vars = {}
+        with open(self.env_file, 'r') as f:
+            for line in f:
+                line = line.strip()
+                if line and not line.startswith('#') and '=' in line:
+                    key, value = line.split('=', 1)
+                    key = key.strip()
+                    value = value.strip().strip('"\'')  # Remove quotes
+                    env_vars[key] = value
+
+        self.loaded_vars = env_vars
+        return env_vars
+
+    def get_required_env_vars(self, services: List[str]) -> List[str]:
+        """
+        Get list of required environment variables for specific services.
+
+        Args:
+            services: List of service names (e.g., ['openai', 'anthropic'])
+
+        Returns:
+            List of required environment variable names
+        """
+        service_requirements = {
+            'openai': ['OPENAI_API_KEY'],
+            'google': ['GOOGLE_API_KEY'],
+            'tavily': ['TAVILY_API_KEY'],
         }
 
+        required = []
+        for service in services:
+            if service.lower() in service_requirements:
+                required.extend(service_requirements[service.lower()])
+
+        return required
+
+    def validate_required_env_vars(self, services: List[str]) -> List[str]:
+        """
+        Validate that required environment variables are set.
+
+        Returns:
+            List of missing environment variables
+        """
+        required = self.get_required_env_vars(services)
+        missing = []
+
+        for var in required:
+            if not os.environ.get(var):
+                missing.append(var)
+
+        return missing
+
+
+class ConfigLoader:
+    """
+    Main configuration loader that handles both Pydantic config and environment variables.
+    """
+
+    def __init__(self, env_file: Optional[str] = None):
+        self.env_manager = EnvironmentVariableManager(env_file)
+        self.config = None
+
+    def load_config(self,
+                    required_services: Optional[List[str]] = None,
+                    validate: bool = True) -> AgentConfig:
+        """
+        Load configuration and set up environment variables.
+
+        Args:
+            required_services: List of services that must have API keys
+            validate: Whether to validate required environment variables
+
+        Returns:
+            Configured LangGraphConfigWithEnvVars instance
+        """
+
+        # Step 1: Load .env file
+        print("Loading .env file...")
+        loaded_vars = self.env_manager.load_env_file()
+        print(f"Loaded {len(loaded_vars)} variables from .env file")
+
+        # Step 2: Load Pydantic configuration
+        print("Loading Pydantic configuration...")
+        self.config = AgentConfig()
+
+        # Step 3: Validate required services
+        if validate and required_services:
+            print(f"Validating required services: {required_services}")
+            missing = self.env_manager.validate_required_env_vars(required_services)
+            if missing:
+                raise ValueError(f"Missing required environment variables: {missing}")
+            print("✓ All required environment variables are set")
+
+        return self.config
+
+
+loader = ConfigLoader()
 
-# Global config instance
-config = AgentConfig()
+config = loader.load_config(
+    required_services=['openai', 'google', 'tavily'],
+    validate=True
+)

nodes/chunking_node.py

@@ -69,7 +69,7 @@ class OversizedContentHandler:
                 raw_content = result['raw_content']
 
                 content_size = self.count_tokens(raw_content)
-                if content_size > config.MAX_CONTEXT_TOKENS:
+                if content_size > config.max_tokens:
                     print(f"Proceed with chunking, evaluated no of tokens {content_size} for message {message.id}")
                     chunked = True
                     result['raw_content'] = self.extract_relevant_chunks(raw_content, query=query)

nodes/nodes.py

@@ -5,6 +5,7 @@ import time
 from langchain_core.messages import SystemMessage, HumanMessage, AIMessage, RemoveMessage
 from langchain_openai import ChatOpenAI
 
+from config.settings import config
 from core.messages import attachmentHandler
 from core.state import State
 from nodes.chunking_node import OversizedContentHandler
@@ -16,15 +17,17 @@ from tools.python_executor import execute_python_code
 from tools.tavily_tools import web_search_tools
 from utils.prompt_manager import prompt_mgmt
 
-model = ChatOpenAI(model="gpt-4.1")
-response_processing_model = ChatOpenAI(model="gpt-4.1-mini")
 web_search_tools.append(query_audio)
 web_search_tools.append(query_excel_file)
 web_search_tools.append(execute_python_code)
 web_search_tools.append(math_tool)
 web_search_tools.append(chess_analysis_tool)
+
+model = ChatOpenAI(model=config.model_name)
 model = model.bind_tools(web_search_tools, parallel_tool_calls=False)
 
+response_processing_model = ChatOpenAI(model=config.response_processing_model_name)
+
 
 # Node
 def pre_processor(state: State):

utils/dependencies_checker.py

@@ -25,7 +25,7 @@ def find_stockfish_path():
 
 
 def check_dependencies():
-    chess_engine_path =os.getenv("CHESS_ENGINE_PATH")
+    chess_engine_path = os.getenv("CHESS_ENGINE_PATH")
     if chess_engine_path is None:
         stockfish_path = find_stockfish_path()
         if stockfish_path: