crewlyze 3.1.0

package/config/llm_config.py

@@ -0,0 +1,300 @@
+# Crewlyze
+# Copyright (c) 2025 Sowmiyan S
+# Licensed under the MIT License
+
+import os
+import requests
+from dotenv import load_dotenv
+
+load_dotenv()
+
+def _load_local_config():
+    try:
+        from pathlib import Path
+        import json
+        cfg_path = Path.home() / ".crewlyze" / "config.json"
+        if cfg_path.exists():
+            with open(cfg_path, "r", encoding="utf-8") as f:
+                cfg = json.load(f)
+                for k, v in cfg.items():
+                    if k not in os.environ:
+                        os.environ[k] = str(v)
+    except Exception:
+        pass
+
+_load_local_config()
+
+# NVIDIA NIM OpenAI-compatible endpoint (required for LiteLLM / CrewAI)
+NVIDIA_NIM_BASE_URL = "https://integrate.api.nvidia.com/v1"
+
+# Keys accepted by crewai.LLM constructor.
+_LLM_VALID_KEYS = {"model", "api_key", "base_url", "temperature", "max_retries", "timeout"}
+
+
+def _sync_nvidia_env(api_key: str) -> None:
+    """Keep NVIDIA env vars in sync for LiteLLM and direct HTTP clients."""
+    if api_key:
+        os.environ["NVIDIA_API_KEY"] = api_key
+        os.environ["NVIDIA_NIM_API_KEY"] = api_key
+
+
+def get_llm_config() -> dict:
+    """Return the raw provider config dict (may contain extra keys)."""
+    from config.context import current_llm_provider, current_llm_api_key
+    provider = current_llm_provider.get() or os.getenv("LLM_PROVIDER", "nvidia")
+
+    configs = {
+        "nvidia": {
+            "model":    "nvidia_nim/meta/llama-3.1-8b-instruct",
+            "api_key":  current_llm_api_key.get() or os.getenv("NVIDIA_API_KEY"),
+            "base_url": NVIDIA_NIM_BASE_URL,
+        },
+        "minimax": {
+            "model":      "nvidia_nim/minimaxai/minimax-m3",
+            "api_key":    current_llm_api_key.get() or os.getenv("NVIDIA_API_KEY"),
+            "base_url":   NVIDIA_NIM_BASE_URL,
+            "max_tokens": 8192,
+            "temperature": 1.00,
+            "top_p":      0.95,
+            "multimodal": True,
+        },
+        "groq": {
+            "model":   "groq/llama-3.1-8b-instant",
+            "api_key": current_llm_api_key.get() or os.getenv("GROQ_API_KEY"),
+        },
+        "custom": {
+            "model":   os.getenv("LLM_MODEL", "custom/model"),
+            "api_key": current_llm_api_key.get() or os.getenv("CUSTOM_API_KEY", ""),
+            "base_url": os.getenv("CUSTOM_BASE_URL"),
+        },
+        "openai": {
+            "model":   "gpt-4o-mini",
+            "api_key": current_llm_api_key.get() or os.getenv("OPENAI_API_KEY"),
+        },
+        "ollama": {
+            "model":    "ollama/llama3",
+            "base_url": current_llm_api_key.get() or os.getenv("OLLAMA_BASE_URL", "http://localhost:11434"),
+        },
+        "anthropic": {
+            "model":   "claude-3-5-sonnet-20241022",
+            "api_key": current_llm_api_key.get() or os.getenv("ANTHROPIC_API_KEY"),
+        },
+        "huggingface": {
+            "model":   "huggingface/HuggingFaceH4/zephyr-7b-beta",
+            "api_key": current_llm_api_key.get() or os.getenv("HUGGINGFACE_API_KEY"),
+        },
+        "mistral": {
+            "model":   "mistral/mistral-tiny",
+            "api_key": current_llm_api_key.get() or os.getenv("MISTRAL_API_KEY"),
+        },
+        "gemini": {
+            "model":   "gemini/gemini-pro",
+            "api_key": current_llm_api_key.get() or os.getenv("GEMINI_API_KEY"),
+        },
+        "cohere": {
+            "model":   "cohere/command-r-plus",
+            "api_key": current_llm_api_key.get() or os.getenv("COHERE_API_KEY"),
+        },
+        "together": {
+            "model":   "together_ai/meta-llama/Llama-3-70b-chat-hf",
+            "api_key": current_llm_api_key.get() or os.getenv("TOGETHER_API_KEY"),
+        },
+        "openrouter": {
+            "model":   "openrouter/google/gemma-2-9b-it",
+            "api_key": current_llm_api_key.get() or os.getenv("OPENROUTER_API_KEY"),
+        },
+        "deepseek": {
+            "model":   "deepseek/deepseek-chat",
+            "api_key": current_llm_api_key.get() or os.getenv("DEEPSEEK_API_KEY"),
+        },
+        "perplexity": {
+            "model":   "perplexity/llama-3-sonar-large-32k-chat",
+            "api_key": current_llm_api_key.get() or os.getenv("PERPLEXITY_API_KEY"),
+        },
+    }
+
+    if provider not in configs:
+        from config.context import current_llm_model
+        model = current_llm_model.get() or os.getenv("LLM_MODEL") or f"{provider}/default"
+        api_key = current_llm_api_key.get() or os.getenv(f"{provider.upper()}_API_KEY") or os.getenv("API_KEY") or ""
+        configs[provider] = {
+            "model": model,
+            "api_key": api_key,
+        }
+
+    config = configs[provider]
+
+    requires_key = {
+        "groq", "openai", "anthropic", "huggingface", "mistral", "gemini", "nvidia", "minimax",
+        "cohere", "together", "openrouter", "deepseek", "perplexity", "custom"
+    }
+    if provider in requires_key and not config.get("api_key"):
+        raise ValueError(
+            f"{provider.upper()}_API_KEY is not set. "
+            "Enter your API key in the sidebar and click Test Connection."
+        )
+
+    if provider in ("nvidia", "minimax") and config.get("api_key"):
+        _sync_nvidia_env(config["api_key"])
+
+    return config
+
+
+def get_llm_params() -> dict:
+    """Return keyword args safe to pass directly to crewai.LLM(**...)."""
+    from config.context import current_llm_model
+    config = get_llm_config()
+    model = current_llm_model.get() or os.getenv("LLM_MODEL") or config["model"]
+
+    params: dict = {
+        "model":       model,
+        "temperature": config.get("temperature", 0.1),
+        "max_retries": 5,
+    }
+
+    if config.get("api_key"):
+        params["api_key"] = config["api_key"]
+
+    if config.get("base_url"):
+        params["base_url"] = config["base_url"]
+
+    return {k: v for k, v in params.items() if k in _LLM_VALID_KEYS}
+
+
+def apply_runtime_llm_settings(
+    provider: str,
+    model: str,
+    api_key: str = "",
+    env_key_name: str = "",
+) -> None:
+    """Inject provider/model/key into context variables before agent execution."""
+
+    if provider == "custom" and api_key and "|" in api_key:
+        parts = api_key.split("|", 1)
+        os.environ["CUSTOM_BASE_URL"] = parts[0]
+        api_key = parts[1]
+
+    from config.context import current_llm_provider, current_llm_model, current_llm_api_key, current_llm_env_key_name
+    current_llm_provider.set(provider)
+    current_llm_model.set(model)
+    current_llm_api_key.set(api_key)
+    current_llm_env_key_name.set(env_key_name)
+
+
+def validate_llm_connection(provider: str, model: str, api_key: str = "") -> dict:
+    """
+    Ping the configured LLM with a minimal prompt.
+    Returns {"valid": bool, "message": str}.
+    """
+
+    if provider == "custom" and api_key and "|" in api_key:
+        parts = api_key.split("|", 1)
+        os.environ["CUSTOM_BASE_URL"] = parts[0]
+        api_key = parts[1]
+
+    if provider == "ollama":
+        env_key_name = "OLLAMA_BASE_URL"
+    elif provider in ("nvidia", "minimax"):
+        env_key_name = "NVIDIA_API_KEY"
+    else:
+        env_key_name = f"{provider.upper()}_API_KEY"
+
+    if provider != "ollama" and not api_key.strip():
+        return {
+            "valid": False,
+            "message": f"Please enter your {provider.upper()} API key.",
+        }
+
+    apply_runtime_llm_settings(provider, model, api_key.strip(), env_key_name)
+
+    # Fast path for NVIDIA: direct HTTP avoids spinning up full CrewAI stack
+    if provider in ("nvidia", "minimax"):
+        try:
+            response = requests.post(
+                f"{NVIDIA_NIM_BASE_URL}/chat/completions",
+                headers={
+                    "Authorization": f"Bearer {api_key.strip()}",
+                    "Content-Type": "application/json",
+                },
+                json={
+                    "model": model.replace("nvidia_nim/", "") if model.startswith("nvidia_nim/") else model,
+                    "messages": [{"role": "user", "content": "Reply with exactly: OK"}],
+                    "max_tokens": 8,
+                    "temperature": 0.1,
+                },
+                timeout=30,
+            )
+            if response.status_code == 401:
+                return {"valid": False, "message": "Invalid NVIDIA API key (401 Unauthorized)."}
+            if response.status_code == 404:
+                return {
+                    "valid": False,
+                    "message": (
+                        f"Model not found on NVIDIA NIM: {model}. "
+                        "Try another model from the dropdown."
+                    ),
+                }
+            response.raise_for_status()
+            data = response.json()
+            preview = (
+                data.get("choices", [{}])[0]
+                .get("message", {})
+                .get("content", "OK")
+            )
+            return {
+                "valid": True,
+                "message": "NVIDIA NIM connection successful.",
+                "preview": str(preview)[:120],
+            }
+        except requests.RequestException as exc:
+            detail = str(exc)
+            if hasattr(exc, "response") and exc.response is not None:
+                try:
+                    detail = exc.response.json().get("detail", detail)
+                except Exception:
+                    detail = exc.response.text[:200] or detail
+            return {"valid": False, "message": f"NVIDIA API error: {detail}"}
+
+    try:
+        from crewai import LLM
+
+        llm = LLM(**get_llm_params())
+        result = llm.call([{"role": "user", "content": "Reply with exactly: OK"}])
+        preview = result if isinstance(result, str) else str(result)
+        return {
+            "valid": True,
+            "message": f"{provider.upper()} connection successful.",
+            "preview": preview[:120],
+        }
+    except Exception as exc:
+        return {"valid": False, "message": str(exc)}
+
+
+def call_minimax_m3(messages: list, stream: bool = False, **kwargs) -> dict:
+    """
+    Direct HTTP client for MiniMax-M3 via NVIDIA NIM.
+    """
+    api_key = os.getenv("NVIDIA_API_KEY")
+    if not api_key:
+        raise ValueError("NVIDIA_API_KEY environment variable is not set.")
+
+    invoke_url = f"{NVIDIA_NIM_BASE_URL}/chat/completions"
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Accept": "text/event-stream" if stream else "application/json",
+    }
+    payload = {
+        "model":       "minimaxai/minimax-m3",
+        "messages":    messages,
+        "max_tokens":  kwargs.get("max_tokens", 8192),
+        "temperature": kwargs.get("temperature", 1.00),
+        "top_p":       kwargs.get("top_p", 0.95),
+        "stream":      stream,
+    }
+
+    response = requests.post(invoke_url, headers=headers, json=payload, stream=stream, timeout=60)
+    response.raise_for_status()
+
+    if stream:
+        return response
+    return response.json()

package/config/metrics_tracker.py

@@ -0,0 +1,70 @@
+# Crewlyze Metrics Tracker
+# Copyright (c) 2026 Sowmiyan S
+# Licensed under the MIT License
+
+import os
+import json
+import time
+from pathlib import Path
+
+def get_metrics_file_path() -> Path:
+    user_home = Path.home() / ".crewlyze"
+    return Path(os.getenv("CREWLYZE_DATA_DIR", str(user_home / "data"))) / "metrics.json"
+
+def log_metric(
+    session_id: str,
+    dataset_name: str,
+    rows: int,
+    cols: int,
+    stages: dict,
+    total_time: float,
+    success: bool = True,
+    token_usage: int = 0,
+    estimated_cost: float = 0.0
+):
+    metrics_path = get_metrics_file_path()
+    metrics_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    new_entry = {
+        "session_id": session_id,
+        "dataset_name": dataset_name,
+        "rows": rows,
+        "columns": cols,
+        "timestamp": time.time() * 1000,  # Milliseconds since epoch
+        "stages": stages,
+        "total_time": total_time,
+        "token_usage": token_usage,
+        "estimated_cost": estimated_cost,
+        "success": success
+    }
+    
+    metrics = []
+    if metrics_path.exists():
+        try:
+            with open(metrics_path, "r", encoding="utf-8") as f:
+                metrics = json.load(f)
+                if not isinstance(metrics, list):
+                    metrics = []
+        except Exception:
+            metrics = []
+            
+    metrics.append(new_entry)
+    
+    # Cap to last 100 entries to prevent file from growing indefinitely
+    metrics = metrics[-100:]
+    
+    try:
+        with open(metrics_path, "w", encoding="utf-8") as f:
+            json.dump(metrics, f, indent=2)
+    except Exception as e:
+        print(f"Failed to save metrics: {e}")
+
+def get_metrics() -> list:
+    metrics_path = get_metrics_file_path()
+    if not metrics_path.exists():
+        return []
+    try:
+        with open(metrics_path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return []