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

causaliq_knowledge/llm/openai_compat_client.py

@@ -0,0 +1,287 @@
+"""Base class for OpenAI-compatible API clients.
+
+This module provides a shared base class for LLM providers that implement
+the OpenAI API format (OpenAI, DeepSeek, Mistral, etc.).
+"""
+
+import logging
+from abc import abstractmethod
+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 OpenAICompatConfig(LLMConfig):
+    """Base configuration for OpenAI-compatible API clients.
+
+    Attributes:
+        model: Model identifier.
+        temperature: Sampling temperature (default: 0.1).
+        max_tokens: Maximum response tokens (default: 500).
+        timeout: Request timeout in seconds (default: 30.0).
+        api_key: API key (provider-specific env var fallback).
+    """
+
+    model: str = "gpt-4o-mini"
+    temperature: float = 0.1
+    max_tokens: int = 500
+    timeout: float = 30.0
+    api_key: Optional[str] = None
+
+
+class OpenAICompatClient(BaseLLMClient):
+    """Base class for OpenAI-compatible API clients.
+
+    Provides shared implementation for providers that use the OpenAI API
+    format (chat/completions endpoint, same request/response structure).
+
+    Subclasses must implement:
+        - BASE_URL: The API base URL
+        - PROVIDER_NAME: Name for logging
+        - ENV_VAR: Environment variable for API key
+        - _get_pricing(): Return pricing dict for cost calculation
+        - _filter_models(): Optional model list filtering
+
+    Example:
+        >>> class MyClient(OpenAICompatClient):
+        ...     BASE_URL = "https://api.example.com/v1"
+        ...     PROVIDER_NAME = "example"
+        ...     ENV_VAR = "EXAMPLE_API_KEY"
+    """
+
+    # Subclasses must override these
+    BASE_URL: str = ""
+    PROVIDER_NAME: str = "openai-compat"
+    ENV_VAR: str = "API_KEY"
+
+    def __init__(self, config: Optional[OpenAICompatConfig] = None) -> None:
+        """Initialize the client.
+
+        Args:
+            config: Client configuration. If None, uses defaults with
+                   API key from environment variable.
+        """
+        self.config = config or self._default_config()
+        self._total_calls = 0
+
+    @abstractmethod
+    def _default_config(self) -> OpenAICompatConfig:
+        """Return default configuration for this provider."""
+        pass
+
+    @property
+    def provider_name(self) -> str:
+        """Return the provider name."""
+        return self.PROVIDER_NAME
+
+    def completion(
+        self, messages: List[Dict[str, str]], **kwargs: Any
+    ) -> LLMResponse:
+        """Make a chat completion request.
+
+        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.
+        """
+        # Build request payload
+        payload = {
+            "model": self.config.model,
+            "messages": messages,
+            "temperature": kwargs.get("temperature", self.config.temperature),
+            "max_tokens": kwargs.get("max_tokens", self.config.max_tokens),
+            "stream": False,
+        }
+
+        headers = {
+            "Authorization": f"Bearer {self.config.api_key}",
+            "Content-Type": "application/json",
+        }
+
+        logger.debug(
+            f"Calling {self.PROVIDER_NAME} API with model: {payload['model']}"
+        )
+
+        try:
+            with httpx.Client(timeout=self.config.timeout) as client:
+                response = client.post(
+                    f"{self.BASE_URL}/chat/completions",
+                    json=payload,
+                    headers=headers,
+                )
+                response.raise_for_status()
+
+                data = response.json()
+
+                # Extract response data
+                content = data["choices"][0]["message"]["content"] or ""
+                usage = data.get("usage", {})
+                input_tokens = usage.get("prompt_tokens", 0)
+                output_tokens = usage.get("completion_tokens", 0)
+
+                self._total_calls += 1
+
+                logger.debug(
+                    f"{self.PROVIDER_NAME} response: "
+                    f"{input_tokens} in, {output_tokens} out"
+                )
+
+                # Calculate cost
+                cost = self._calculate_cost(
+                    self.config.model, input_tokens, output_tokens
+                )
+
+                return LLMResponse(
+                    content=content,
+                    model=data.get("model", self.config.model),
+                    input_tokens=input_tokens,
+                    output_tokens=output_tokens,
+                    cost=cost,
+                    raw_response=data,
+                )
+
+        except httpx.HTTPStatusError as e:
+            msg = f"{self.PROVIDER_NAME} API error: {e.response.status_code}"
+            logger.error(f"{msg} - {e.response.text}")
+            raise ValueError(f"{msg} - {e.response.text}")
+        except httpx.TimeoutException:
+            raise ValueError(f"{self.PROVIDER_NAME} API request timed out")
+        except Exception as e:
+            logger.error(f"{self.PROVIDER_NAME} API unexpected error: {e}")
+            raise ValueError(f"{self.PROVIDER_NAME} API error: {str(e)}")
+
+    def _calculate_cost(
+        self, model: str, input_tokens: int, output_tokens: int
+    ) -> float:
+        """Calculate approximate cost for API call.
+
+        Args:
+            model: Model identifier.
+            input_tokens: Number of input tokens.
+            output_tokens: Number of output tokens.
+
+        Returns:
+            Estimated cost in USD.
+        """
+        pricing = self._get_pricing()
+
+        # Find matching pricing (check if model starts with known prefix)
+        model_pricing = None
+        for key in pricing:
+            if model.startswith(key):
+                model_pricing = pricing[key]
+                break
+
+        if not model_pricing:
+            return 0.0
+
+        input_cost = (input_tokens / 1_000_000) * model_pricing["input"]
+        output_cost = (output_tokens / 1_000_000) * model_pricing["output"]
+
+        return input_cost + output_cost
+
+    @abstractmethod
+    def _get_pricing(self) -> Dict[str, Dict[str, float]]:
+        """Return pricing dict for this provider.
+
+        Returns:
+            Dict mapping model prefixes to input/output costs per 1M tokens.
+            Example: {"gpt-4o": {"input": 2.50, "output": 10.00}}
+        """
+        pass
+
+    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 the API is available.
+
+        Returns:
+            True if API key is configured.
+        """
+        return bool(self.config.api_key)
+
+    def list_models(self) -> List[str]:
+        """List available models from the API.
+
+        Queries the API to get models accessible with the current
+        API key, then filters using _filter_models().
+
+        Returns:
+            List of model identifiers.
+
+        Raises:
+            ValueError: If the API request fails.
+        """
+        try:
+            with httpx.Client(timeout=self.config.timeout) as client:
+                response = client.get(
+                    f"{self.BASE_URL}/models",
+                    headers={"Authorization": f"Bearer {self.config.api_key}"},
+                )
+                response.raise_for_status()
+                data = response.json()
+
+                # Get model IDs from response
+                all_models = [
+                    model.get("id", "") for model in data.get("data", [])
+                ]
+
+                # Filter using provider-specific logic
+                models = self._filter_models(all_models)
+
+                return sorted(models)
+
+        except httpx.HTTPStatusError as e:
+            msg = f"{self.PROVIDER_NAME} API error: {e.response.status_code}"
+            raise ValueError(f"{msg} - {e.response.text}")
+        except Exception as e:
+            raise ValueError(
+                f"Failed to list {self.PROVIDER_NAME} models: {e}"
+            )
+
+    def _filter_models(self, models: List[str]) -> List[str]:
+        """Filter model list to relevant models.
+
+        Override in subclasses to customize filtering.
+
+        Args:
+            models: List of all model IDs from API.
+
+        Returns:
+            Filtered list of relevant model IDs.
+        """
+        return models

causaliq_knowledge/llm/provider.py

@@ -4,8 +4,19 @@ import logging
 from typing import Any, Dict, Optional, Union
 
 from causaliq_knowledge.base import KnowledgeProvider
+from causaliq_knowledge.llm.anthropic_client import (
+    AnthropicClient,
+    AnthropicConfig,
+)
+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.models import EdgeDirection, EdgeKnowledge
 
@@ -164,6 +175,7 @@ class LLMKnowledge(KnowledgeProvider):
             models: List of model identifiers. Supported formats:
                 - "groq/llama-3.1-8b-instant" (Groq API)
                 - "gemini/gemini-2.5-flash" (Google Gemini API)
+                - "ollama/llama3.2:1b" (Local Ollama server)
                 Defaults to ["groq/llama-3.1-8b-instant"].
             consensus_strategy: How to combine multi-model responses.
                 Options: "weighted_vote", "highest_confidence".
@@ -190,9 +202,30 @@ class LLMKnowledge(KnowledgeProvider):
         self._consensus_fn = CONSENSUS_STRATEGIES[consensus_strategy]
 
         # Create a client for each model - use direct APIs only
-        self._clients: dict[str, Union[GroqClient, GeminiClient]] = {}
+        self._clients: dict[
+            str,
+            Union[
+                AnthropicClient,
+                DeepSeekClient,
+                GeminiClient,
+                GroqClient,
+                MistralClient,
+                OllamaClient,
+                OpenAIClient,
+            ],
+        ] = {}
         for model in models:
-            if model.startswith("groq/"):
+            if model.startswith("anthropic/"):
+                # Use direct Anthropic client for Claude models
+                anthropic_model = model.split("/", 1)[1]  # Extract model name
+                anthropic_config = AnthropicConfig(
+                    model=anthropic_model,
+                    temperature=temperature,
+                    max_tokens=max_tokens,
+                    timeout=timeout,
+                )
+                self._clients[model] = AnthropicClient(config=anthropic_config)
+            elif model.startswith("groq/"):
                 # Use direct Groq client - more reliable than litellm
                 groq_model = model.split("/", 1)[1]  # Extract model name
                 config = GroqConfig(
@@ -212,9 +245,57 @@ class LLMKnowledge(KnowledgeProvider):
                     timeout=timeout,
                 )
                 self._clients[model] = GeminiClient(config=gemini_config)
+            elif model.startswith("ollama/"):
+                # Use local Ollama client for running models locally
+                ollama_model = model.split("/", 1)[1]  # Extract model name
+                ollama_config = OllamaConfig(
+                    model=ollama_model,
+                    temperature=temperature,
+                    max_tokens=max_tokens,
+                    timeout=timeout,
+                )
+                self._clients[model] = OllamaClient(config=ollama_config)
+            elif model.startswith("openai/"):
+                # Use direct OpenAI client for GPT models
+                openai_model = model.split("/", 1)[1]  # Extract model name
+                openai_config = OpenAIConfig(
+                    model=openai_model,
+                    temperature=temperature,
+                    max_tokens=max_tokens,
+                    timeout=timeout,
+                )
+                self._clients[model] = OpenAIClient(config=openai_config)
+            elif model.startswith("deepseek/"):
+                # Use direct DeepSeek client for DeepSeek models
+                deepseek_model = model.split("/", 1)[1]  # Extract model name
+                deepseek_config = DeepSeekConfig(
+                    model=deepseek_model,
+                    temperature=temperature,
+                    max_tokens=max_tokens,
+                    timeout=timeout,
+                )
+                self._clients[model] = DeepSeekClient(config=deepseek_config)
+            elif model.startswith("mistral/"):
+                # Use direct Mistral client for Mistral models
+                mistral_model = model.split("/", 1)[1]  # Extract model name
+                mistral_config = MistralConfig(
+                    model=mistral_model,
+                    temperature=temperature,
+                    max_tokens=max_tokens,
+                    timeout=timeout,
+                )
+                self._clients[model] = MistralClient(config=mistral_config)
             else:
                 # Only direct API clients are supported
-                supported_prefixes = ["groq/", "gemini/"]
+                supported_prefixes = [
+                    "anthropic/",
+                    "deepseek/",
+                    "gemini/",
+                    "groq/",
+                    "mistral/",
+                    "ollama/",
+                    "openai/",
+                ]
                 raise ValueError(
                     f"Model '{model}' not supported. "
                     f"Supported prefixes: {supported_prefixes}."
@@ -262,35 +343,17 @@ class LLMKnowledge(KnowledgeProvider):
         responses: list[EdgeKnowledge] = []
         for model, client in self._clients.items():
             try:
-                if isinstance(client, GroqClient):
-                    # Direct Groq API call
-                    messages = []
-                    if system_prompt:
-                        messages.append(
-                            {"role": "system", "content": system_prompt}
-                        )
-                    messages.append({"role": "user", "content": user_prompt})
-
-                    json_data, _ = client.complete_json(messages)
-                    knowledge = parse_edge_response(json_data, model=model)
-                    responses.append(knowledge)
-                elif isinstance(client, GeminiClient):
-                    # Direct Gemini API call
-                    messages = []
-                    if system_prompt:
-                        messages.append(
-                            {"role": "system", "content": system_prompt}
-                        )
-                    messages.append({"role": "user", "content": user_prompt})
-
-                    json_data, _ = client.complete_json(messages)
-                    knowledge = parse_edge_response(json_data, model=model)
-                    responses.append(knowledge)
-                else:
-                    # Should never reach here due to constructor validation
-                    raise ValueError(
-                        f"Unsupported client type for model {model}"
+                # All clients implement BaseLLMClient interface
+                messages = []
+                if system_prompt:
+                    messages.append(
+                        {"role": "system", "content": system_prompt}
                     )
+                messages.append({"role": "user", "content": user_prompt})
+
+                json_data, _ = client.complete_json(messages)
+                knowledge = parse_edge_response(json_data, model=model)
+                responses.append(knowledge)
             except Exception as e:
                 # On error, add uncertain response
                 responses.append(
@@ -314,21 +377,11 @@ class LLMKnowledge(KnowledgeProvider):
         per_model: Dict[str, Dict[str, Any]] = {}
 
         for model, client in self._clients.items():
-            if isinstance(client, GroqClient):
-                # Direct Groq client stats
-                stats: Dict[str, Any] = {
-                    "call_count": client.call_count,
-                    "total_cost": 0.0,  # Free tier
-                }
-            elif isinstance(client, GeminiClient):
-                # Direct Gemini client stats
-                stats = {
-                    "call_count": client.call_count,
-                    "total_cost": 0.0,  # Free tier
-                }
-            else:
-                # Should never reach here due to constructor validation
-                raise ValueError(f"Unsupported client type for model {model}")
+            # All clients implement BaseLLMClient with call_count property
+            stats: Dict[str, Any] = {
+                "call_count": client.call_count,
+                "total_cost": 0.0,  # All current providers are free tier
+            }
 
             total_calls += stats["call_count"]
             total_cost += stats["total_cost"]

{causaliq_knowledge-0.1.0.dist-info → causaliq_knowledge-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: causaliq-knowledge
-Version: 0.1.0
+Version: 0.3.0
 Summary: Incorporating LLM and human knowledge into causal discovery
 Author-email: CausalIQ <info@causaliq.com>
 Maintainer-email: CausalIQ <info@causaliq.com>
@@ -85,18 +85,14 @@ print(f"Reasoning: {result.reasoning}")
 
 ## Features
 
-Under development:
-
-- **Release v0.1.0 - Foundation LLM**: Simple LLM queries to 1 or 2 LLMs about edge existence and orientation to support graph averaging
-
 Currently implemented releases:
 
-- None
+- **Release v0.1.0 - Foundation LLM**: Simple LLM queries to 1 or 2 LLMs about edge existence and orientation to support graph averaging
+- **Release v0.2.0 - Additional LLMs**: Support for 7 LLM providers (Groq, Gemini, OpenAI, Anthropic, DeepSeek, Mistral, Ollama)
+- **Release v0.3.0 - LLM Caching** *(in development)*: SQLite-based response caching with CLI tools for cache management
 
 Planned:
 
-- **Release v0.2.0 - Additional LLMs**: Support for more LLM providers (OpenAI, Anthropic)
-- **Release v0.3.0 - LLM Caching**: Caching of LLM queries and responses
 - **Release v0.4.0 - LLM Context**: Variable/role/literature etc context
 - **Release v0.5.0 - Algorithm integration**: Integration into structure learning algorithms
 - **Release v0.6.0 - Legacy Reference**: Support for legacy approaches of deriving knowledge from reference networks
@@ -128,8 +124,11 @@ This approach keeps the package lightweight, reliable, and easy to debug.
 |----------|--------|--------|-----------|
 | **Groq** | `GroqClient` | llama-3.1-8b-instant | ✅ Generous |
 | **Google Gemini** | `GeminiClient` | gemini-2.5-flash | ✅ Generous |
-
-Additional providers (OpenAI, Anthropic) can be added in future releases.
+| **OpenAI** | `OpenAIClient` | gpt-4o-mini | ❌ Paid |
+| **Anthropic** | `AnthropicClient` | claude-sonnet-4-20250514 | ❌ Paid |
+| **DeepSeek** | `DeepSeekClient` | deepseek-chat | ✅ Low cost |
+| **Mistral** | `MistralClient` | mistral-small-latest | ❌ Paid |
+| **Ollama** | `OllamaClient` | llama3 | ✅ Free (local) |
 
 ## Upcoming Key Innovations
 

causaliq_knowledge-0.3.0.dist-info/RECORD

@@ -0,0 +1,28 @@
+causaliq_knowledge/__init__.py,sha256=3m-1i0_giGiTzvJj_8lDrMrvpDvnPD3IBOGlU3ZmxfM,843
+causaliq_knowledge/base.py,sha256=GBG-sftOKkmUoQzTpm6anDTjP-2nInRZN_36dxoYhvk,2917
+causaliq_knowledge/cli.py,sha256=FjdlpQ62Mm4SjWGLAaXnPdv8hYh73-IUweLQAhrBw9k,25010
+causaliq_knowledge/models.py,sha256=tWGf186ASwO8NHiN97pEOLuBJmJI6Q9jvpU0mYZNdS0,4058
+causaliq_knowledge/cache/__init__.py,sha256=Av92YdCdVTRt9TmB2edRsIFDxq3f1Qi0daq0sFV1rp0,549
+causaliq_knowledge/cache/token_cache.py,sha256=dURih1jr0csVBxU1pCtmcjV48GnQeCnVGi3j1E0KY7Q,21845
+causaliq_knowledge/cache/encoders/__init__.py,sha256=gZ7gw96paFDbnJuc4v1aJsEJfVinI4zc03tXyFvfZxo,461
+causaliq_knowledge/cache/encoders/base.py,sha256=jK7--Or3lVp1UkKghKYFo_gKJp0HsMxosL_8eYL7RQQ,2679
+causaliq_knowledge/cache/encoders/json_encoder.py,sha256=44mcYpT6vJaJT9ZwtnWwdxCvTXIFyoeolqyiAXrgH1o,15110
+causaliq_knowledge/llm/__init__.py,sha256=30AL0h64zIkXoiqhMY7gjaf7mrtwtwMW38vzhns0My4,1663
+causaliq_knowledge/llm/anthropic_client.py,sha256=dPFHYGWL4xwQCtmQuGwGY4DBKSINOgOS-11ekznaiXo,8719
+causaliq_knowledge/llm/base_client.py,sha256=o2qWu2_ttKMHT4isdkY4VUjma3B3jtdx1vhOLXVFLX4,12249
+causaliq_knowledge/llm/cache.py,sha256=gBjZaYNJZ8HF54Hk25RWGVOvdBFwVPAv78_GYaanRTc,12723
+causaliq_knowledge/llm/deepseek_client.py,sha256=ZcOpgnYa66XHjiTaF5ekR_BtosRYvVmzlIafp_Gsx_A,3543
+causaliq_knowledge/llm/gemini_client.py,sha256=XJMq9sPo7zExrALSr2rIRHLheSPqKo8ENG0KtdJ1cjw,9924
+causaliq_knowledge/llm/groq_client.py,sha256=PnTXqtMF1Km9DY4HiCZXQ6LeOzdjZtQJaeuGe1GbeME,7531
+causaliq_knowledge/llm/mistral_client.py,sha256=dTAOtymffCM1AJp5-JcfizofYrUA-jhKfHWrhZe2DDI,4187
+causaliq_knowledge/llm/ollama_client.py,sha256=PPU3g-nD8D546zcYB3uGxZ9yVbU4Gngo3snM2tRFeTc,8612
+causaliq_knowledge/llm/openai_client.py,sha256=MJmB6P32TZESMlXhn9d0-b3vFWXmf7ojHQ5CY8mCENI,3835
+causaliq_knowledge/llm/openai_compat_client.py,sha256=L8ZW5csuhUePq4mt3EGOUqhR3tleFmM72UlhPBsgIMQ,9518
+causaliq_knowledge/llm/prompts.py,sha256=bJ9iVGKUfTfLi2eWh-FFM4cNzk5Ux4Z0x8R6Ia27Dbo,6598
+causaliq_knowledge/llm/provider.py,sha256=VDEv-1esT_EgJk_Gwlfl4423ojglOxzPCBCFbOFE4DQ,15184
+causaliq_knowledge-0.3.0.dist-info/licenses/LICENSE,sha256=vUFUzQnti-D-MLSi9NxFlsFYOKwU25sxxH7WgJOQFIs,1084
+causaliq_knowledge-0.3.0.dist-info/METADATA,sha256=MIE-z6VqrnzuhHpU8j0DzxB48zwyDIobseO2SltVe-0,8774
+causaliq_knowledge-0.3.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+causaliq_knowledge-0.3.0.dist-info/entry_points.txt,sha256=8iQjiMgFxZszRWwSTGHvoOBb_OBUkMmwvH3PzgsH-Cc,104
+causaliq_knowledge-0.3.0.dist-info/top_level.txt,sha256=GcxQf4BQAGa38i2-j8ylk2FmnBHtEZ9-8bSt-7Uka7k,19
+causaliq_knowledge-0.3.0.dist-info/RECORD,,

{causaliq_knowledge-0.1.0.dist-info → causaliq_knowledge-0.3.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

causaliq_knowledge-0.1.0.dist-info/RECORD

@@ -1,15 +0,0 @@
-causaliq_knowledge/__init__.py,sha256=E0QHb_Tu2lwzRVmyqbR357eFuusUeZ226SbD9y5UxCU,851
-causaliq_knowledge/base.py,sha256=GBG-sftOKkmUoQzTpm6anDTjP-2nInRZN_36dxoYhvk,2917
-causaliq_knowledge/cli.py,sha256=CFw6nhULlR6x3Wbu5uQNLd-mLpYu8TKQWA9xpeSRx6E,5695
-causaliq_knowledge/models.py,sha256=tWGf186ASwO8NHiN97pEOLuBJmJI6Q9jvpU0mYZNdS0,4058
-causaliq_knowledge/llm/__init__.py,sha256=hrb0AHRc3lRWFpcEtJmtZwA9QK3k6bxPymp08gXaiZk,791
-causaliq_knowledge/llm/gemini_client.py,sha256=fP9D6M0AFCtRnVbQrvaT-0EruQG0OWchdNaFS1Ph4z8,7046
-causaliq_knowledge/llm/groq_client.py,sha256=5-xfLvvSN8sd_T6niQE8ZLimG9sPCz_n5_nl0YNAqI4,4888
-causaliq_knowledge/llm/prompts.py,sha256=bJ9iVGKUfTfLi2eWh-FFM4cNzk5Ux4Z0x8R6Ia27Dbo,6598
-causaliq_knowledge/llm/provider.py,sha256=f9taEmbN0tJ4I04OHd6I-lSLAKEe3px3i0FJFj0N0EI,12995
-causaliq_knowledge-0.1.0.dist-info/licenses/LICENSE,sha256=vUFUzQnti-D-MLSi9NxFlsFYOKwU25sxxH7WgJOQFIs,1084
-causaliq_knowledge-0.1.0.dist-info/METADATA,sha256=dKZxJtIIFzkkLKefzwKvUp-9fYj4BqumnqWbNWVczws,8464
-causaliq_knowledge-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-causaliq_knowledge-0.1.0.dist-info/entry_points.txt,sha256=8iQjiMgFxZszRWwSTGHvoOBb_OBUkMmwvH3PzgsH-Cc,104
-causaliq_knowledge-0.1.0.dist-info/top_level.txt,sha256=GcxQf4BQAGa38i2-j8ylk2FmnBHtEZ9-8bSt-7Uka7k,19
-causaliq_knowledge-0.1.0.dist-info/RECORD,,