lfx-nightly 0.1.13.dev0__py3-none-any.whl → 0.2.0.dev26__py3-none-any.whl

lfx/base/models/groq_model_discovery.py

@@ -0,0 +1,265 @@
+"""Dynamic Groq model discovery and tool calling detection.
+
+This module fetches available models directly from the Groq API
+and tests their tool calling capabilities programmatically,
+eliminating the need for manual metadata updates.
+"""
+
+import json
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any
+
+import requests
+
+from lfx.log.logger import logger
+
+
+class GroqModelDiscovery:
+    """Discovers and caches Groq model capabilities dynamically."""
+
+    # Cache file location - use local cache directory within models
+    CACHE_FILE = Path(__file__).parent / ".cache" / "groq_models_cache.json"
+    CACHE_DURATION = timedelta(hours=24)  # Refresh cache every 24 hours
+
+    # Models to skip from LLM list (audio, TTS, guards)
+    SKIP_PATTERNS = ["whisper", "tts", "guard", "safeguard", "prompt-guard", "saba"]
+
+    def __init__(self, api_key: str | None = None, base_url: str = "https://api.groq.com"):
+        """Initialize discovery with optional API key for testing.
+
+        Args:
+            api_key: Groq API key. If None, only cached data will be used.
+            base_url: Groq API base URL
+        """
+        self.api_key = api_key
+        self.base_url = base_url
+
+    def get_models(self, *, force_refresh: bool = False) -> dict[str, dict[str, Any]]:
+        """Get available models with their capabilities.
+
+        Args:
+            force_refresh: If True, bypass cache and fetch fresh data
+
+        Returns:
+            Dictionary mapping model IDs to their metadata:
+            {
+                "model-id": {
+                    "name": "model-id",
+                    "provider": "Provider Name",
+                    "tool_calling": True/False,
+                    "preview": True/False,
+                    "not_supported": True/False,  # for non-LLM models
+                    "last_tested": "2025-01-06T10:30:00"
+                }
+            }
+        """
+        # Try to load from cache first
+        if not force_refresh:
+            cached = self._load_cache()
+            if cached:
+                logger.info("Using cached Groq model metadata")
+                return cached
+
+        # Fetch fresh data from API
+        if not self.api_key:
+            logger.warning("No API key provided, using minimal fallback list")
+            return self._get_fallback_models()
+
+        try:
+            models_metadata = {}
+
+            # Step 1: Get list of available models
+            available_models = self._fetch_available_models()
+            logger.info(f"Found {len(available_models)} models from Groq API")
+
+            # Step 2: Categorize models
+            llm_models = []
+            non_llm_models = []
+
+            for model_id in available_models:
+                if any(pattern in model_id.lower() for pattern in self.SKIP_PATTERNS):
+                    non_llm_models.append(model_id)
+                else:
+                    llm_models.append(model_id)
+
+            # Step 3: Test LLM models for tool calling
+            logger.info(f"Testing {len(llm_models)} LLM models for tool calling support...")
+            for model_id in llm_models:
+                supports_tools = self._test_tool_calling(model_id)
+                models_metadata[model_id] = {
+                    "name": model_id,
+                    "provider": self._get_provider_name(model_id),
+                    "tool_calling": supports_tools,
+                    "preview": "preview" in model_id.lower() or "/" in model_id,
+                    "last_tested": datetime.now(timezone.utc).isoformat(),
+                }
+                logger.debug(f"{model_id}: tool_calling={supports_tools}")
+
+            # Step 4: Add non-LLM models as unsupported
+            for model_id in non_llm_models:
+                models_metadata[model_id] = {
+                    "name": model_id,
+                    "provider": self._get_provider_name(model_id),
+                    "not_supported": True,
+                    "last_tested": datetime.now(timezone.utc).isoformat(),
+                }
+
+            # Save to cache
+            self._save_cache(models_metadata)
+
+        except (requests.RequestException, KeyError, ValueError, ImportError) as e:
+            logger.exception(f"Error discovering models: {e}")
+            return self._get_fallback_models()
+        else:
+            return models_metadata
+
+    def _fetch_available_models(self) -> list[str]:
+        """Fetch list of available models from Groq API."""
+        url = f"{self.base_url}/openai/v1/models"
+        headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
+
+        response = requests.get(url, headers=headers, timeout=10)
+        response.raise_for_status()
+
+        model_list = response.json()
+        # Use direct access to raise KeyError if 'data' is missing
+        return [model["id"] for model in model_list["data"]]
+
+    def _test_tool_calling(self, model_id: str) -> bool:
+        """Test if a model supports tool calling.
+
+        Args:
+            model_id: The model ID to test
+
+        Returns:
+            True if model supports tool calling, False otherwise
+        """
+        try:
+            import groq
+
+            client = groq.Groq(api_key=self.api_key)
+
+            # Simple tool definition
+            tools = [
+                {
+                    "type": "function",
+                    "function": {
+                        "name": "test_tool",
+                        "description": "A test tool",
+                        "parameters": {
+                            "type": "object",
+                            "properties": {"x": {"type": "string"}},
+                            "required": ["x"],
+                        },
+                    },
+                }
+            ]
+
+            messages = [{"role": "user", "content": "test"}]
+
+            # Try to make a request with tools
+            client.chat.completions.create(
+                model=model_id, messages=messages, tools=tools, tool_choice="auto", max_tokens=10
+            )
+
+        except (ImportError, AttributeError, TypeError, ValueError, RuntimeError, KeyError) as e:
+            error_msg = str(e).lower()
+            # If error mentions tool calling, model doesn't support it
+            if "tool" in error_msg:
+                return False
+            # Other errors might be rate limits, etc - be conservative
+            logger.warning(f"Error testing {model_id}: {e}")
+            return False
+        else:
+            return True
+
+    def _get_provider_name(self, model_id: str) -> str:
+        """Extract provider name from model ID."""
+        if "/" in model_id:
+            provider_map = {
+                "meta-llama": "Meta",
+                "openai": "OpenAI",
+                "groq": "Groq",
+                "moonshotai": "Moonshot AI",
+                "qwen": "Alibaba Cloud",
+            }
+            prefix = model_id.split("/")[0]
+            return provider_map.get(prefix, prefix.title())
+
+        # Common patterns
+        if model_id.startswith("llama"):
+            return "Meta"
+        if model_id.startswith("qwen"):
+            return "Alibaba Cloud"
+        if model_id.startswith("allam"):
+            return "SDAIA"
+
+        return "Groq"
+
+    def _load_cache(self) -> dict[str, dict] | None:
+        """Load cached model metadata if it exists and is fresh."""
+        if not self.CACHE_FILE.exists():
+            return None
+
+        try:
+            with self.CACHE_FILE.open() as f:
+                cache_data = json.load(f)
+
+            # Check cache age
+            cache_time = datetime.fromisoformat(cache_data["cached_at"])
+            if datetime.now(timezone.utc) - cache_time > self.CACHE_DURATION:
+                logger.info("Cache expired, will fetch fresh data")
+                return None
+
+            return cache_data["models"]
+
+        except (json.JSONDecodeError, KeyError, ValueError) as e:
+            logger.warning(f"Invalid cache file: {e}")
+            return None
+
+    def _save_cache(self, models_metadata: dict[str, dict]) -> None:
+        """Save model metadata to cache."""
+        try:
+            cache_data = {"cached_at": datetime.now(timezone.utc).isoformat(), "models": models_metadata}
+
+            self.CACHE_FILE.parent.mkdir(parents=True, exist_ok=True)
+            with self.CACHE_FILE.open("w") as f:
+                json.dump(cache_data, f, indent=2)
+
+            logger.info(f"Cached {len(models_metadata)} models to {self.CACHE_FILE}")
+
+        except (OSError, TypeError, ValueError) as e:
+            logger.warning(f"Failed to save cache: {e}")
+
+    def _get_fallback_models(self) -> dict[str, dict]:
+        """Return minimal fallback list when API is unavailable."""
+        return {
+            "llama-3.1-8b-instant": {
+                "name": "llama-3.1-8b-instant",
+                "provider": "Meta",
+                "tool_calling": True,
+                "preview": False,
+            },
+            "llama-3.3-70b-versatile": {
+                "name": "llama-3.3-70b-versatile",
+                "provider": "Meta",
+                "tool_calling": True,
+                "preview": False,
+            },
+        }
+
+
+# Convenience function for use in other modules
+def get_groq_models(api_key: str | None = None, *, force_refresh: bool = False) -> dict[str, dict]:
+    """Get Groq models with their capabilities.
+
+    Args:
+        api_key: Optional API key for testing. If None, uses cached data.
+        force_refresh: If True, bypass cache and fetch fresh data.
+
+    Returns:
+        Dictionary of model metadata
+    """
+    discovery = GroqModelDiscovery(api_key=api_key)
+    return discovery.get_models(force_refresh=force_refresh)

lfx/base/models/model.py

@@ -296,7 +296,7 @@ class LCModelComponent(Component):
             )
             model_message.properties.source = self._build_source(self._id, self.display_name, self)
             lf_message = await self.send_message(model_message)
-            result = lf_message.text
+            result = lf_message.text or ""
         else:
             message = await runnable.ainvoke(inputs)
             result = message.content if hasattr(message, "content") else message

lfx/base/models/model_input_constants.py

@@ -14,14 +14,18 @@ class ModelProvidersDict(TypedDict):
     is_active: bool
 
 
-def get_filtered_inputs(component_class):
+def get_filtered_inputs(component_class, provider_name: str | None = None):
     base_input_names = {field.name for field in LCModelComponent.get_base_inputs()}
     component_instance = component_class()
 
-    return [process_inputs(input_) for input_ in component_instance.inputs if input_.name not in base_input_names]
+    return [
+        process_inputs(input_, provider_name)
+        for input_ in component_instance.inputs
+        if input_.name not in base_input_names
+    ]
 
 
-def process_inputs(component_data: Input):
+def process_inputs(component_data: Input, provider_name: str | None = None):
     """Processes and modifies an input configuration based on its type or name.
 
     Adjusts properties such as value, advanced status, real-time refresh, and additional information for specific
@@ -29,6 +33,7 @@ def process_inputs(component_data: Input):
 
     Args:
         component_data: The input configuration to process.
+        provider_name: The name of the provider to process the inputs for.
 
     Returns:
         The modified input configuration.
@@ -43,9 +48,11 @@ def process_inputs(component_data: Input):
         component_data.advanced = True
         component_data.value = True
     elif component_data.name in {"temperature", "base_url"}:
-        component_data = set_advanced_true(component_data)
+        if provider_name not in ["IBM watsonx.ai", "Ollama"]:
+            component_data = set_advanced_true(component_data)
     elif component_data.name == "model_name":
-        component_data = set_real_time_refresh_false(component_data)
+        if provider_name not in ["IBM watsonx.ai"]:
+            component_data = set_real_time_refresh_false(component_data)
         component_data = add_combobox_true(component_data)
         component_data = add_info(
             component_data,
@@ -79,6 +86,28 @@ def create_input_fields_dict(inputs: list[Input], prefix: str) -> dict[str, Inpu
     return {f"{prefix}{input_.name}": input_.to_dict() for input_ in inputs}
 
 
+def _get_ollama_inputs_and_fields():
+    try:
+        from lfx.components.ollama.ollama import ChatOllamaComponent
+
+        ollama_inputs = get_filtered_inputs(ChatOllamaComponent, provider_name="Ollama")
+    except ImportError as e:
+        msg = "Ollama is not installed. Please install it with `pip install langchain-ollama`."
+        raise ImportError(msg) from e
+    return ollama_inputs, create_input_fields_dict(ollama_inputs, "")
+
+
+def _get_watsonx_inputs_and_fields():
+    try:
+        from lfx.components.ibm.watsonx import WatsonxAIComponent
+
+        watsonx_inputs = get_filtered_inputs(WatsonxAIComponent, provider_name="IBM watsonx.ai")
+    except ImportError as e:
+        msg = "IBM watsonx.ai is not installed. Please install it with `pip install langchain-ibm-watsonx`."
+        raise ImportError(msg) from e
+    return watsonx_inputs, create_input_fields_dict(watsonx_inputs, "")
+
+
 def _get_google_generative_ai_inputs_and_fields():
     try:
         from lfx.components.google.google_generative_ai import GoogleGenerativeAIComponent
@@ -293,6 +322,36 @@ try:
 except ImportError:
     pass
 
+try:
+    from lfx.components.ibm.watsonx import WatsonxAIComponent
+
+    watsonx_inputs, watsonx_fields = _get_watsonx_inputs_and_fields()
+    MODEL_PROVIDERS_DICT["IBM watsonx.ai"] = {
+        "fields": watsonx_fields,
+        "inputs": watsonx_inputs,
+        "prefix": "",
+        "component_class": WatsonxAIComponent(),
+        "icon": WatsonxAIComponent.icon,
+        "is_active": True,
+    }
+except ImportError:
+    pass
+
+try:
+    from lfx.components.ollama.ollama import ChatOllamaComponent
+
+    ollama_inputs, ollama_fields = _get_ollama_inputs_and_fields()
+    MODEL_PROVIDERS_DICT["Ollama"] = {
+        "fields": ollama_fields,
+        "inputs": ollama_inputs,
+        "prefix": "",
+        "component_class": ChatOllamaComponent(),
+        "icon": ChatOllamaComponent.icon,
+        "is_active": True,
+    }
+except ImportError:
+    pass
+
 # Expose only active providers ----------------------------------------------
 ACTIVE_MODEL_PROVIDERS_DICT: dict[str, ModelProvidersDict] = {
     name: prov for name, prov in MODEL_PROVIDERS_DICT.items() if prov.get("is_active", True)
@@ -302,10 +361,18 @@ MODEL_PROVIDERS: list[str] = list(ACTIVE_MODEL_PROVIDERS_DICT.keys())
 
 ALL_PROVIDER_FIELDS: list[str] = [field for prov in ACTIVE_MODEL_PROVIDERS_DICT.values() for field in prov["fields"]]
 
-MODEL_DYNAMIC_UPDATE_FIELDS = ["api_key", "model", "tool_model_enabled", "base_url", "model_name"]
+MODEL_DYNAMIC_UPDATE_FIELDS = [
+    "api_key",
+    "model",
+    "tool_model_enabled",
+    "base_url",
+    "model_name",
+    "watsonx_endpoint",
+    "url",
+]
 
 MODELS_METADATA = {name: {"icon": prov["icon"]} for name, prov in ACTIVE_MODEL_PROVIDERS_DICT.items()}
 
-MODEL_PROVIDERS_LIST = ["Anthropic", "Google Generative AI", "OpenAI"]
+MODEL_PROVIDERS_LIST = ["Anthropic", "Google Generative AI", "OpenAI", "IBM watsonx.ai", "Ollama"]
 
 MODEL_OPTIONS_METADATA = [MODELS_METADATA[key] for key in MODEL_PROVIDERS_LIST if key in MODELS_METADATA]

lfx/base/models/model_utils.py

@@ -1,3 +1,14 @@
+import asyncio
+from urllib.parse import urljoin
+
+import httpx
+
+from lfx.log.logger import logger
+from lfx.utils.util import transform_localhost_url
+
+HTTP_STATUS_OK = 200
+
+
 def get_model_name(llm, display_name: str | None = "Custom"):
     attributes_to_check = ["model_name", "model", "model_id", "deployment_name"]
 
@@ -6,3 +17,92 @@ def get_model_name(llm, display_name: str | None = "Custom"):
 
     # If no matching attribute is found, return the class name as a fallback
     return model_name if model_name is not None else display_name
+
+
+async def is_valid_ollama_url(url: str) -> bool:
+    """Check if the provided URL is a valid Ollama API endpoint."""
+    try:
+        url = transform_localhost_url(url)
+        if not url:
+            return False
+        # Strip /v1 suffix if present, as Ollama API endpoints are at root level
+        url = url.rstrip("/").removesuffix("/v1")
+        if not url.endswith("/"):
+            url = url + "/"
+        async with httpx.AsyncClient() as client:
+            return (await client.get(url=urljoin(url, "api/tags"))).status_code == HTTP_STATUS_OK
+    except httpx.RequestError:
+        logger.debug(f"Invalid Ollama URL: {url}")
+        return False
+
+
+async def get_ollama_models(
+    base_url_value: str, desired_capability: str, json_models_key: str, json_name_key: str, json_capabilities_key: str
+) -> list[str]:
+    """Fetch available completion models from the Ollama API.
+
+    Filters out embedding models and only returns models with completion capability.
+
+    Args:
+        base_url_value (str): The base URL of the Ollama API.
+        desired_capability (str): The desired capability of the model.
+        json_models_key (str): The key in the JSON response that contains the models.
+        json_name_key (str): The key in the JSON response that contains the model names.
+        json_capabilities_key (str): The key in the JSON response that contains the model capabilities.
+
+    Returns:
+        list[str]: A sorted list of model names that support completion.
+
+    Raises:
+        ValueError: If there is an issue with the API request or response.
+    """
+    try:
+        # Strip /v1 suffix if present, as Ollama API endpoints are at root level
+        base_url = base_url_value.rstrip("/").removesuffix("/v1")
+        if not base_url.endswith("/"):
+            base_url = base_url + "/"
+        base_url = transform_localhost_url(base_url)
+
+        # Ollama REST API to return models
+        tags_url = urljoin(base_url, "api/tags")
+
+        # Ollama REST API to return model capabilities
+        show_url = urljoin(base_url, "api/show")
+        tags_response = None
+
+        async with httpx.AsyncClient() as client:
+            # Fetch available models
+            tags_response = await client.get(url=tags_url)
+            tags_response.raise_for_status()
+            models = tags_response.json()
+            if asyncio.iscoroutine(models):
+                models = await models
+            await logger.adebug(f"Available models: {models}")
+
+            # Filter models that are NOT embedding models
+            model_ids = []
+            for model in models.get(json_models_key, []):
+                model_name = model.get(json_name_key)
+                if not model_name:
+                    continue
+                await logger.adebug(f"Checking model: {model_name}")
+
+                payload = {"model": model_name}
+                show_response = await client.post(url=show_url, json=payload)
+                show_response.raise_for_status()
+                json_data = show_response.json()
+                if asyncio.iscoroutine(json_data):
+                    json_data = await json_data
+
+                capabilities = json_data.get(json_capabilities_key, [])
+                await logger.adebug(f"Model: {model_name}, Capabilities: {capabilities}")
+
+                if desired_capability in capabilities:
+                    model_ids.append(model_name)
+
+            return sorted(model_ids)
+
+    except (httpx.RequestError, ValueError) as e:
+        msg = "Could not get model names from Ollama."
+        await logger.aexception(msg)
+        raise ValueError(msg) from e

lfx/base/models/ollama_constants.py

@@ -47,3 +47,6 @@ URL_LIST = [
     "http://127.0.0.1:11434",
     "http://0.0.0.0:11434",
 ]
+
+
+DEFAULT_OLLAMA_API_URL = "https://ollama.com"

lfx/base/models/openai_constants.py

@@ -3,6 +3,13 @@ from .model_metadata import create_model_metadata
 # Unified model metadata - single source of truth
 OPENAI_MODELS_DETAILED = [
     # GPT-5 Series
+    create_model_metadata(
+        provider="OpenAI",
+        name="gpt-5.1",
+        icon="OpenAI",
+        tool_calling=True,
+        reasoning=True,
+    ),
     create_model_metadata(
         provider="OpenAI",
         name="gpt-5",

lfx/base/models/watsonx_constants.py

@@ -0,0 +1,36 @@
+from .model_metadata import create_model_metadata
+
+WATSONX_DEFAULT_EMBEDDING_MODELS = [
+    create_model_metadata(
+        provider="IBM Watsonx",
+        name="sentence-transformers/all-minilm-l12-v2",
+        icon="WatsonxAI",
+    ),
+    create_model_metadata(
+        provider="IBM Watsonx",
+        name="ibm/slate-125m-english-rtrvr-v2",
+        icon="WatsonxAI",
+    ),
+    create_model_metadata(
+        provider="IBM Watsonx",
+        name="ibm/slate-30m-english-rtrvr-v2",
+        icon="WatsonxAI",
+    ),
+    create_model_metadata(
+        provider="IBM Watsonx",
+        name="intfloat/multilingual-e5-large",
+        icon="WatsonxAI",
+    ),
+]
+
+
+WATSONX_EMBEDDING_MODEL_NAMES = [metadata["name"] for metadata in WATSONX_DEFAULT_EMBEDDING_MODELS]
+
+IBM_WATSONX_URLS = [
+    "https://us-south.ml.cloud.ibm.com",
+    "https://eu-de.ml.cloud.ibm.com",
+    "https://eu-gb.ml.cloud.ibm.com",
+    "https://au-syd.ml.cloud.ibm.com",
+    "https://jp-tok.ml.cloud.ibm.com",
+    "https://ca-tor.ml.cloud.ibm.com",
+]