causaliq-knowledge 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

causaliq_knowledge/__init__.py

@@ -5,7 +5,7 @@ causaliq-knowledge: LLM and human knowledge for causal discovery.
 from causaliq_knowledge.base import KnowledgeProvider
 from causaliq_knowledge.models import EdgeDirection, EdgeKnowledge
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"
 __author__ = "CausalIQ"
 __email__ = "info@causaliq.com"
 

causaliq_knowledge/cli.py

@@ -150,51 +150,258 @@ def query_edge(
 
 
 @cli.command("models")
-def list_models() -> None:
-    """List supported LLM models.
+@click.argument("provider", required=False, default=None)
+def list_models(provider: Optional[str]) -> None:
+    """List available LLM models from each provider.
 
-    These are model identifiers that work with our direct API clients.
-    Only models with direct API support are listed.
+    Queries each provider's API to show models accessible with your
+    current configuration. Results are filtered by your API key's
+    access level or locally installed models.
+
+    Optionally specify PROVIDER to list models from a single provider:
+    groq, anthropic, gemini, ollama, openai, deepseek, or mistral.
+
+    Examples:
+
+        cqknow models              # List all providers
+
+        cqknow models groq         # List only Groq models
+
+        cqknow models mistral      # List only Mistral models
     """
-    models = [
-        (
-            "Groq (Fast, Free Tier Available)",
-            [
-                "groq/llama-3.1-8b-instant",
-                "groq/llama-3.1-70b-versatile",
-                "groq/llama-3.2-1b-preview",
-                "groq/llama-3.2-3b-preview",
-                "groq/mixtral-8x7b-32768",
-                "groq/gemma-7b-it",
-                "groq/gemma2-9b-it",
-            ],
-        ),
-        (
-            "Google Gemini (Free Tier Available)",
-            [
-                "gemini/gemini-2.5-flash",
-                "gemini/gemini-1.5-pro",
-                "gemini/gemini-1.5-flash",
-                "gemini/gemini-1.5-flash-8b",
-            ],
-        ),
+    from typing import Callable, List, Optional, Tuple, TypedDict
+
+    from causaliq_knowledge.llm import (
+        AnthropicClient,
+        AnthropicConfig,
+        DeepSeekClient,
+        DeepSeekConfig,
+        GeminiClient,
+        GeminiConfig,
+        GroqClient,
+        GroqConfig,
+        MistralClient,
+        MistralConfig,
+        OllamaClient,
+        OllamaConfig,
+        OpenAIClient,
+        OpenAIConfig,
+    )
+
+    # Type for get_models functions
+    GetModelsFunc = Callable[[], Tuple[bool, List[str], Optional[str]]]
+
+    class ProviderInfo(TypedDict):
+        name: str
+        prefix: str
+        env_var: Optional[str]
+        url: str
+        get_models: GetModelsFunc
+
+    def get_groq_models() -> Tuple[bool, List[str], Optional[str]]:
+        """Returns (available, models, error_msg)."""
+        try:
+            client = GroqClient(GroqConfig())
+            if not client.is_available():
+                return False, [], "GROQ_API_KEY not set"
+            models = [f"groq/{m}" for m in client.list_models()]
+            return True, models, None
+        except ValueError as e:
+            return False, [], str(e)
+
+    def get_anthropic_models() -> Tuple[bool, List[str], Optional[str]]:
+        """Returns (available, models, error_msg)."""
+        try:
+            client = AnthropicClient(AnthropicConfig())
+            if not client.is_available():
+                return False, [], "ANTHROPIC_API_KEY not set"
+            models = [f"anthropic/{m}" for m in client.list_models()]
+            return True, models, None
+        except ValueError as e:
+            return False, [], str(e)
+
+    def get_gemini_models() -> Tuple[bool, List[str], Optional[str]]:
+        """Returns (available, models, error_msg)."""
+        try:
+            client = GeminiClient(GeminiConfig())
+            if not client.is_available():
+                return False, [], "GEMINI_API_KEY not set"
+            models = [f"gemini/{m}" for m in client.list_models()]
+            return True, models, None
+        except ValueError as e:
+            return False, [], str(e)
+
+    def get_ollama_models() -> Tuple[bool, List[str], Optional[str]]:
+        """Returns (available, models, error_msg)."""
+        try:
+            client = OllamaClient(OllamaConfig())
+            models = [f"ollama/{m}" for m in client.list_models()]
+            if not models:
+                msg = "No models installed. Run: ollama pull <model>"
+                return True, [], msg
+            return True, models, None
+        except ValueError as e:
+            return False, [], str(e)
+
+    def get_openai_models() -> Tuple[bool, List[str], Optional[str]]:
+        """Returns (available, models, error_msg)."""
+        try:
+            client = OpenAIClient(OpenAIConfig())
+            if not client.is_available():
+                return False, [], "OPENAI_API_KEY not set"
+            models = [f"openai/{m}" for m in client.list_models()]
+            return True, models, None
+        except ValueError as e:
+            return False, [], str(e)
+
+    def get_deepseek_models() -> Tuple[bool, List[str], Optional[str]]:
+        """Returns (available, models, error_msg)."""
+        try:
+            client = DeepSeekClient(DeepSeekConfig())
+            if not client.is_available():
+                return False, [], "DEEPSEEK_API_KEY not set"
+            models = [f"deepseek/{m}" for m in client.list_models()]
+            return True, models, None
+        except ValueError as e:
+            return False, [], str(e)
+
+    def get_mistral_models() -> Tuple[bool, List[str], Optional[str]]:
+        """Returns (available, models, error_msg)."""
+        try:
+            client = MistralClient(MistralConfig())
+            if not client.is_available():
+                return False, [], "MISTRAL_API_KEY not set"
+            models = [f"mistral/{m}" for m in client.list_models()]
+            return True, models, None
+        except ValueError as e:
+            return False, [], str(e)
+
+    providers: List[ProviderInfo] = [
+        {
+            "name": "Groq",
+            "prefix": "groq/",
+            "env_var": "GROQ_API_KEY",
+            "url": "https://console.groq.com",
+            "get_models": get_groq_models,
+        },
+        {
+            "name": "Anthropic",
+            "prefix": "anthropic/",
+            "env_var": "ANTHROPIC_API_KEY",
+            "url": "https://console.anthropic.com",
+            "get_models": get_anthropic_models,
+        },
+        {
+            "name": "Gemini",
+            "prefix": "gemini/",
+            "env_var": "GEMINI_API_KEY",
+            "url": "https://aistudio.google.com",
+            "get_models": get_gemini_models,
+        },
+        {
+            "name": "Ollama (Local)",
+            "prefix": "ollama/",
+            "env_var": None,
+            "url": "https://ollama.ai",
+            "get_models": get_ollama_models,
+        },
+        {
+            "name": "OpenAI",
+            "prefix": "openai/",
+            "env_var": "OPENAI_API_KEY",
+            "url": "https://platform.openai.com",
+            "get_models": get_openai_models,
+        },
+        {
+            "name": "DeepSeek",
+            "prefix": "deepseek/",
+            "env_var": "DEEPSEEK_API_KEY",
+            "url": "https://platform.deepseek.com",
+            "get_models": get_deepseek_models,
+        },
+        {
+            "name": "Mistral",
+            "prefix": "mistral/",
+            "env_var": "MISTRAL_API_KEY",
+            "url": "https://console.mistral.ai",
+            "get_models": get_mistral_models,
+        },
     ]
 
-    click.echo("\nSupported LLM Models (Direct API Access):\n")
-    for provider, model_list in models:
-        click.echo(f"  {provider}:")
-        for m in model_list:
-            click.echo(f"    - {m}")
+    # Filter providers if a specific one is requested
+    valid_provider_names = [
+        "groq",
+        "anthropic",
+        "gemini",
+        "ollama",
+        "openai",
+        "deepseek",
+        "mistral",
+    ]
+    if provider:
+        provider_lower = provider.lower()
+        if provider_lower not in valid_provider_names:
+            click.echo(
+                f"Unknown provider: {provider}. "
+                f"Valid options: {', '.join(valid_provider_names)}",
+                err=True,
+            )
+            sys.exit(1)
+        providers = [
+            p for p in providers if p["prefix"].rstrip("/") == provider_lower
+        ]
+
+    click.echo("\nAvailable LLM Models:\n")
+
+    any_available = False
+    for prov in providers:
+        available, models, error = prov["get_models"]()
+
+        if available and models:
+            any_available = True
+            status = click.style("[OK]", fg="green")
+            count = len(models)
+            click.echo(f"  {status} {prov['name']} ({count} models):")
+            for m in models:
+                click.echo(f"      {m}")
+        elif available and not models:
+            status = click.style("[!]", fg="yellow")
+            click.echo(f"  {status} {prov['name']}:")
+            click.echo(f"      {error}")
+        else:
+            status = click.style("[X]", fg="red")
+            click.echo(f"  {status} {prov['name']}:")
+            click.echo(f"      {error}")
+
+        click.echo()
+
+    click.echo("Provider Setup:")
+    for prov in providers:
+        available, _, _ = prov["get_models"]()
+        if prov["env_var"]:
+            status = "configured" if available else "not set"
+            color = "green" if available else "yellow"
+            click.echo(
+                f"  {prov['env_var']}: "
+                f"{click.style(status, fg=color)} - {prov['url']}"
+            )
+        else:
+            status = "running" if available else "not running"
+            color = "green" if available else "yellow"
+            click.echo(
+                f"  Ollama server: "
+                f"{click.style(status, fg=color)} - {prov['url']}"
+            )
+
     click.echo()
-    click.echo("Required API Keys:")
-    click.echo(
-        "  GROQ_API_KEY      - Get free API key at https://console.groq.com"
-    )
     click.echo(
-        "  GEMINI_API_KEY    - Get free API key at https://aistudio.google.com"
+        click.style("Note: ", fg="yellow")
+        + "Some models may require a paid plan. "
+        + "Free tier availability varies by provider."
     )
     click.echo()
-    click.echo("Default model: groq/llama-3.1-8b-instant")
+    if any_available:
+        click.echo("Default model: groq/llama-3.1-8b-instant")
     click.echo()
 
 

causaliq_knowledge/llm/__init__.py

@@ -1,15 +1,23 @@
 """LLM integration module for causaliq-knowledge."""
 
-from causaliq_knowledge.llm.gemini_client import (
-    GeminiClient,
-    GeminiConfig,
-    GeminiResponse,
+from causaliq_knowledge.llm.anthropic_client import (
+    AnthropicClient,
+    AnthropicConfig,
 )
-from causaliq_knowledge.llm.groq_client import (
-    GroqClient,
-    GroqConfig,
-    GroqResponse,
+from causaliq_knowledge.llm.base_client import (
+    BaseLLMClient,
+    LLMConfig,
+    LLMResponse,
 )
+from causaliq_knowledge.llm.deepseek_client import (
+    DeepSeekClient,
+    DeepSeekConfig,
+)
+from causaliq_knowledge.llm.gemini_client import GeminiClient, GeminiConfig
+from causaliq_knowledge.llm.groq_client import GroqClient, GroqConfig
+from causaliq_knowledge.llm.mistral_client import MistralClient, MistralConfig
+from causaliq_knowledge.llm.ollama_client import OllamaClient, OllamaConfig
+from causaliq_knowledge.llm.openai_client import OpenAIClient, OpenAIConfig
 from causaliq_knowledge.llm.prompts import EdgeQueryPrompt, parse_edge_response
 from causaliq_knowledge.llm.provider import (
     CONSENSUS_STRATEGIES,
@@ -19,14 +27,35 @@ from causaliq_knowledge.llm.provider import (
 )
 
 __all__ = [
+    # Abstract base
+    "BaseLLMClient",
+    "LLMConfig",
+    "LLMResponse",
+    # Anthropic
+    "AnthropicClient",
+    "AnthropicConfig",
+    # Consensus
     "CONSENSUS_STRATEGIES",
+    # DeepSeek
+    "DeepSeekClient",
+    "DeepSeekConfig",
     "EdgeQueryPrompt",
+    # Gemini
     "GeminiClient",
     "GeminiConfig",
-    "GeminiResponse",
+    # Groq
     "GroqClient",
     "GroqConfig",
-    "GroqResponse",
+    # Mistral
+    "MistralClient",
+    "MistralConfig",
+    # Ollama (local)
+    "OllamaClient",
+    "OllamaConfig",
+    # OpenAI
+    "OpenAIClient",
+    "OpenAIConfig",
+    # Provider
     "LLMKnowledge",
     "highest_confidence",
     "parse_edge_response",

causaliq_knowledge/llm/anthropic_client.py

@@ -0,0 +1,256 @@
+"""Direct Anthropic API client - clean and reliable."""
+
+import logging
+import os
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+
+import httpx
+
+from causaliq_knowledge.llm.base_client import (
+    BaseLLMClient,
+    LLMConfig,
+    LLMResponse,
+)
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class AnthropicConfig(LLMConfig):
+    """Configuration for Anthropic API client.
+
+    Extends LLMConfig with Anthropic-specific defaults.
+
+    Attributes:
+        model: Anthropic model identifier (default: claude-sonnet-4-20250514).
+        temperature: Sampling temperature (default: 0.1).
+        max_tokens: Maximum response tokens (default: 500).
+        timeout: Request timeout in seconds (default: 30.0).
+        api_key: Anthropic API key (falls back to ANTHROPIC_API_KEY env var).
+    """
+
+    model: str = "claude-sonnet-4-20250514"
+    temperature: float = 0.1
+    max_tokens: int = 500
+    timeout: float = 30.0
+    api_key: Optional[str] = None
+
+    def __post_init__(self) -> None:
+        """Set API key from environment if not provided."""
+        if self.api_key is None:
+            self.api_key = os.getenv("ANTHROPIC_API_KEY")
+        if not self.api_key:
+            raise ValueError(
+                "ANTHROPIC_API_KEY environment variable is required"
+            )
+
+
+class AnthropicClient(BaseLLMClient):
+    """Direct Anthropic API client.
+
+    Implements the BaseLLMClient interface for Anthropic's Claude API.
+    Uses httpx for HTTP requests.
+
+    Example:
+        >>> config = AnthropicConfig(model="claude-sonnet-4-20250514")
+        >>> client = AnthropicClient(config)
+        >>> msgs = [{"role": "user", "content": "Hello"}]
+        >>> response = client.completion(msgs)
+        >>> print(response.content)
+    """
+
+    BASE_URL = "https://api.anthropic.com/v1"
+    API_VERSION = "2023-06-01"
+
+    def __init__(self, config: Optional[AnthropicConfig] = None) -> None:
+        """Initialize Anthropic client.
+
+        Args:
+            config: Anthropic configuration. If None, uses defaults with
+                   API key from ANTHROPIC_API_KEY environment variable.
+        """
+        self.config = config or AnthropicConfig()
+        self._total_calls = 0
+
+    @property
+    def provider_name(self) -> str:
+        """Return the provider name."""
+        return "anthropic"
+
+    def completion(
+        self, messages: List[Dict[str, str]], **kwargs: Any
+    ) -> LLMResponse:
+        """Make a chat completion request to Anthropic.
+
+        Args:
+            messages: List of message dicts with "role" and "content" keys.
+            **kwargs: Override config options (temperature, max_tokens).
+
+        Returns:
+            LLMResponse with the generated content and metadata.
+
+        Raises:
+            ValueError: If the API request fails.
+        """
+        # Anthropic uses separate system parameter, not in messages
+        system_content = None
+        filtered_messages = []
+
+        for msg in messages:
+            if msg["role"] == "system":
+                system_content = msg["content"]
+            else:
+                filtered_messages.append(msg)
+
+        # Build request payload in Anthropic's format
+        payload: Dict[str, Any] = {
+            "model": self.config.model,
+            "messages": filtered_messages,
+            "max_tokens": kwargs.get("max_tokens", self.config.max_tokens),
+            "temperature": kwargs.get("temperature", self.config.temperature),
+        }
+
+        # Add system prompt if present
+        if system_content:
+            payload["system"] = system_content
+
+        # api_key is guaranteed non-None after __post_init__ validation
+        headers: dict[str, str] = {
+            "x-api-key": self.config.api_key,  # type: ignore[dict-item]
+            "anthropic-version": self.API_VERSION,
+            "Content-Type": "application/json",
+        }
+
+        logger.debug(f"Calling Anthropic API with model: {self.config.model}")
+
+        try:
+            with httpx.Client(timeout=self.config.timeout) as client:
+                response = client.post(
+                    f"{self.BASE_URL}/messages",
+                    json=payload,
+                    headers=headers,
+                )
+                response.raise_for_status()
+
+                data = response.json()
+
+                # Extract response content from Anthropic format
+                content_blocks = data.get("content", [])
+                content = ""
+                for block in content_blocks:
+                    if block.get("type") == "text":
+                        content += block.get("text", "")
+
+                # Extract usage info
+                usage = data.get("usage", {})
+                input_tokens = usage.get("input_tokens", 0)
+                output_tokens = usage.get("output_tokens", 0)
+
+                self._total_calls += 1
+
+                logger.debug(
+                    f"Anthropic response: {input_tokens} in, "
+                    f"{output_tokens} out"
+                )
+
+                return LLMResponse(
+                    content=content,
+                    model=data.get("model", self.config.model),
+                    input_tokens=input_tokens,
+                    output_tokens=output_tokens,
+                    cost=0.0,  # Cost calculation not implemented
+                    raw_response=data,
+                )
+
+        except httpx.HTTPStatusError as e:
+            try:
+                error_data = e.response.json()
+                error_msg = error_data.get("error", {}).get(
+                    "message", e.response.text
+                )
+            except Exception:
+                error_msg = e.response.text
+
+            logger.error(
+                f"Anthropic API HTTP error: {e.response.status_code} - "
+                f"{error_msg}"
+            )
+            raise ValueError(
+                f"Anthropic API error: {e.response.status_code} - {error_msg}"
+            )
+        except httpx.TimeoutException:
+            raise ValueError("Anthropic API request timed out")
+        except Exception as e:
+            logger.error(f"Anthropic API unexpected error: {e}")
+            raise ValueError(f"Anthropic API error: {str(e)}")
+
+    def complete_json(
+        self, messages: List[Dict[str, str]], **kwargs: Any
+    ) -> tuple[Optional[Dict[str, Any]], LLMResponse]:
+        """Make a completion request and parse response as JSON.
+
+        Args:
+            messages: List of message dicts with "role" and "content" keys.
+            **kwargs: Override config options passed to completion().
+
+        Returns:
+            Tuple of (parsed JSON dict or None, raw LLMResponse).
+        """
+        response = self.completion(messages, **kwargs)
+        parsed = response.parse_json()
+        return parsed, response
+
+    @property
+    def call_count(self) -> int:
+        """Return the number of API calls made."""
+        return self._total_calls
+
+    def is_available(self) -> bool:
+        """Check if Anthropic API is available.
+
+        Returns:
+            True if ANTHROPIC_API_KEY is configured.
+        """
+        return bool(self.config.api_key)
+
+    def list_models(self) -> List[str]:
+        """List available Claude models from Anthropic API.
+
+        Queries the Anthropic /v1/models endpoint to get available models.
+
+        Returns:
+            List of model identifiers
+            (e.g., ['claude-sonnet-4-20250514', ...]).
+        """
+        if not self.config.api_key:
+            return []
+
+        headers: dict[str, str] = {
+            "x-api-key": self.config.api_key,
+            "anthropic-version": self.API_VERSION,
+        }
+
+        try:
+            with httpx.Client(timeout=self.config.timeout) as client:
+                response = client.get(
+                    f"{self.BASE_URL}/models",
+                    headers=headers,
+                )
+                response.raise_for_status()
+
+                data = response.json()
+                models = []
+                for model_info in data.get("data", []):
+                    model_id = model_info.get("id")
+                    if model_id:
+                        models.append(model_id)
+
+                return sorted(models)
+
+        except httpx.HTTPStatusError as e:
+            logger.warning(f"Anthropic API error listing models: {e}")
+            return []
+        except Exception as e:
+            logger.warning(f"Error listing Anthropic models: {e}")
+            return []