cognify-code 0.2.0__py3-none-any.whl

ai_code_assistant/providers/factory.py

@@ -0,0 +1,148 @@
+"""Factory for creating LLM providers."""
+
+from typing import Dict, List, Optional, Type
+
+from ai_code_assistant.providers.base import (
+    BaseProvider,
+    ModelInfo,
+    ProviderConfig,
+    ProviderType,
+)
+from ai_code_assistant.providers.ollama import OllamaProvider
+from ai_code_assistant.providers.google import GoogleProvider
+from ai_code_assistant.providers.groq import GroqProvider
+from ai_code_assistant.providers.cerebras import CerebrasProvider
+from ai_code_assistant.providers.openrouter import OpenRouterProvider
+from ai_code_assistant.providers.openai import OpenAIProvider
+
+
+# Registry of all available providers
+PROVIDER_REGISTRY: Dict[ProviderType, Type[BaseProvider]] = {
+    ProviderType.OLLAMA: OllamaProvider,
+    ProviderType.GOOGLE: GoogleProvider,
+    ProviderType.GROQ: GroqProvider,
+    ProviderType.CEREBRAS: CerebrasProvider,
+    ProviderType.OPENROUTER: OpenRouterProvider,
+    ProviderType.OPENAI: OpenAIProvider,
+}
+
+
+def get_provider(config: ProviderConfig) -> BaseProvider:
+    """
+    Create a provider instance based on configuration.
+
+    Args:
+        config: Provider configuration
+
+    Returns:
+        Configured provider instance
+
+    Raises:
+        ValueError: If provider type is not supported
+    """
+    provider_class = PROVIDER_REGISTRY.get(config.provider)
+    if not provider_class:
+        supported = ", ".join(p.value for p in ProviderType)
+        raise ValueError(
+            f"Unsupported provider: {config.provider}. "
+            f"Supported providers: {supported}"
+        )
+
+    return provider_class(config)
+
+
+def get_available_providers() -> Dict[str, Dict]:
+    """
+    Get information about all available providers.
+
+    Returns:
+        Dictionary with provider info including name, models, and setup instructions
+    """
+    providers = {}
+    for provider_type, provider_class in PROVIDER_REGISTRY.items():
+        providers[provider_type.value] = {
+            "display_name": provider_class.display_name,
+            "requires_api_key": provider_class.requires_api_key,
+            "free_tier": provider_class.free_tier,
+            "default_model": provider_class.default_model,
+            "models": [m.model_dump() for m in provider_class.available_models],
+            "setup_instructions": provider_class.get_setup_instructions(),
+        }
+    return providers
+
+
+def get_all_models() -> List[ModelInfo]:
+    """
+    Get all available models across all providers.
+
+    Returns:
+        List of all available models
+    """
+    models = []
+    for provider_class in PROVIDER_REGISTRY.values():
+        models.extend(provider_class.available_models)
+    return models
+
+
+def get_free_models() -> List[ModelInfo]:
+    """
+    Get all free models across all providers.
+
+    Returns:
+        List of free models
+    """
+    return [m for m in get_all_models() if m.is_free]
+
+
+def get_provider_for_model(model_name: str) -> Optional[ProviderType]:
+    """
+    Find which provider a model belongs to.
+
+    Args:
+        model_name: Name of the model
+
+    Returns:
+        Provider type or None if not found
+    """
+    for provider_class in PROVIDER_REGISTRY.values():
+        for model in provider_class.available_models:
+            if model.name == model_name:
+                return provider_class.provider_type
+    return None
+
+
+def create_provider_from_env() -> BaseProvider:
+    """
+    Create a provider based on available environment variables.
+
+    Checks for API keys in order of preference and creates the appropriate provider.
+
+    Returns:
+        Configured provider instance
+    """
+    import os
+
+    # Check providers in order of preference (free tiers first)
+    env_checks = [
+        ("GROQ_API_KEY", ProviderType.GROQ, GroqProvider.default_model),
+        ("GOOGLE_API_KEY", ProviderType.GOOGLE, GoogleProvider.default_model),
+        ("CEREBRAS_API_KEY", ProviderType.CEREBRAS, CerebrasProvider.default_model),
+        ("OPENROUTER_API_KEY", ProviderType.OPENROUTER, OpenRouterProvider.default_model),
+        ("OPENAI_API_KEY", ProviderType.OPENAI, OpenAIProvider.default_model),
+    ]
+
+    for env_var, provider_type, default_model in env_checks:
+        if os.getenv(env_var):
+            config = ProviderConfig(
+                provider=provider_type,
+                model=default_model,
+                api_key=os.getenv(env_var),
+            )
+            return get_provider(config)
+
+    # Default to Ollama (no API key required)
+    config = ProviderConfig(
+        provider=ProviderType.OLLAMA,
+        model=OllamaProvider.default_model,
+    )
+    return get_provider(config)

ai_code_assistant/providers/google.py

@@ -0,0 +1,103 @@
+"""Google AI Studio (Gemini) provider."""
+
+import os
+from langchain_core.language_models import BaseChatModel
+
+from ai_code_assistant.providers.base import (
+    BaseProvider,
+    ModelInfo,
+    ProviderConfig,
+    ProviderType,
+)
+
+
+class GoogleProvider(BaseProvider):
+    """Provider for Google AI Studio / Gemini."""
+
+    provider_type = ProviderType.GOOGLE
+    display_name = "Google AI Studio (Gemini)"
+    requires_api_key = True
+    default_model = "gemini-2.0-flash"
+    free_tier = True
+
+    available_models = [
+        ModelInfo(
+            name="gemini-2.0-flash",
+            provider=ProviderType.GOOGLE,
+            description="Gemini 2.0 Flash - Fast and capable, great free tier",
+            context_window=1000000,
+            is_free=True,
+        ),
+        ModelInfo(
+            name="gemini-2.0-flash-lite",
+            provider=ProviderType.GOOGLE,
+            description="Gemini 2.0 Flash Lite - Faster, lighter version",
+            context_window=1000000,
+            is_free=True,
+        ),
+        ModelInfo(
+            name="gemini-1.5-pro",
+            provider=ProviderType.GOOGLE,
+            description="Gemini 1.5 Pro - Most capable Gemini model",
+            context_window=2000000,
+            is_free=True,
+        ),
+        ModelInfo(
+            name="gemini-1.5-flash",
+            provider=ProviderType.GOOGLE,
+            description="Gemini 1.5 Flash - Fast and efficient",
+            context_window=1000000,
+            is_free=True,
+        ),
+    ]
+
+    def _create_llm(self) -> BaseChatModel:
+        """Create Google Gemini LLM instance."""
+        try:
+            from langchain_google_genai import ChatGoogleGenerativeAI
+        except ImportError:
+            raise ImportError(
+                "langchain-google-genai is required for Google provider. "
+                "Install with: pip install langchain-google-genai"
+            )
+
+        api_key = self.config.api_key or os.getenv("GOOGLE_API_KEY")
+        if not api_key:
+            raise ValueError(
+                "Google API key is required. Set GOOGLE_API_KEY environment variable "
+                "or provide api_key in config. Get your key at: https://aistudio.google.com/apikey"
+            )
+
+        return ChatGoogleGenerativeAI(
+            model=self.config.model,
+            google_api_key=api_key,
+            temperature=self.config.temperature,
+            max_output_tokens=self.config.max_tokens,
+            timeout=self.config.timeout,
+        )
+
+    def validate_config(self) -> tuple[bool, str]:
+        """Validate Google configuration."""
+        api_key = self.config.api_key or os.getenv("GOOGLE_API_KEY")
+        if not api_key:
+            return False, "GOOGLE_API_KEY environment variable or api_key config is required"
+        if not self.config.model:
+            return False, "Model name is required"
+        return True, ""
+
+    @classmethod
+    def get_setup_instructions(cls) -> str:
+        """Get Google AI Studio setup instructions."""
+        return """
+Google AI Studio Setup Instructions:
+1. Go to https://aistudio.google.com/apikey
+2. Create a new API key
+3. Set environment variable: export GOOGLE_API_KEY="your-key"
+4. Or add to config.yaml:
+   llm:
+     provider: google
+     api_key: "your-key"
+     model: gemini-2.0-flash
+
+Free tier: 15 requests/minute, 1M tokens/day
+"""

ai_code_assistant/providers/groq.py

@@ -0,0 +1,111 @@
+"""Groq provider for fast LLM inference."""
+
+import os
+from langchain_core.language_models import BaseChatModel
+
+from ai_code_assistant.providers.base import (
+    BaseProvider,
+    ModelInfo,
+    ProviderConfig,
+    ProviderType,
+)
+
+
+class GroqProvider(BaseProvider):
+    """Provider for Groq - extremely fast inference."""
+
+    provider_type = ProviderType.GROQ
+    display_name = "Groq (Fast Inference)"
+    requires_api_key = True
+    default_model = "llama-3.3-70b-versatile"
+    free_tier = True
+
+    available_models = [
+        ModelInfo(
+            name="llama-3.3-70b-versatile",
+            provider=ProviderType.GROQ,
+            description="Llama 3.3 70B - Most capable, 1000 req/day free",
+            context_window=128000,
+            is_free=True,
+        ),
+        ModelInfo(
+            name="llama-3.1-8b-instant",
+            provider=ProviderType.GROQ,
+            description="Llama 3.1 8B - Fast, 14400 req/day free",
+            context_window=128000,
+            is_free=True,
+        ),
+        ModelInfo(
+            name="llama3-70b-8192",
+            provider=ProviderType.GROQ,
+            description="Llama 3 70B - Powerful general model",
+            context_window=8192,
+            is_free=True,
+        ),
+        ModelInfo(
+            name="mixtral-8x7b-32768",
+            provider=ProviderType.GROQ,
+            description="Mixtral 8x7B - Great for code",
+            context_window=32768,
+            is_free=True,
+        ),
+        ModelInfo(
+            name="gemma2-9b-it",
+            provider=ProviderType.GROQ,
+            description="Gemma 2 9B - Google's efficient model",
+            context_window=8192,
+            is_free=True,
+        ),
+    ]
+
+    def _create_llm(self) -> BaseChatModel:
+        """Create Groq LLM instance."""
+        try:
+            from langchain_groq import ChatGroq
+        except ImportError:
+            raise ImportError(
+                "langchain-groq is required for Groq provider. "
+                "Install with: pip install langchain-groq"
+            )
+
+        api_key = self.config.api_key or os.getenv("GROQ_API_KEY")
+        if not api_key:
+            raise ValueError(
+                "Groq API key is required. Set GROQ_API_KEY environment variable "
+                "or provide api_key in config. Get your key at: https://console.groq.com/keys"
+            )
+
+        return ChatGroq(
+            model=self.config.model,
+            api_key=api_key,
+            temperature=self.config.temperature,
+            max_tokens=self.config.max_tokens,
+            timeout=self.config.timeout,
+        )
+
+    def validate_config(self) -> tuple[bool, str]:
+        """Validate Groq configuration."""
+        api_key = self.config.api_key or os.getenv("GROQ_API_KEY")
+        if not api_key:
+            return False, "GROQ_API_KEY environment variable or api_key config is required"
+        if not self.config.model:
+            return False, "Model name is required"
+        return True, ""
+
+    @classmethod
+    def get_setup_instructions(cls) -> str:
+        """Get Groq setup instructions."""
+        return """
+Groq Setup Instructions:
+1. Go to https://console.groq.com/keys
+2. Create a free account and generate an API key
+3. Set environment variable: export GROQ_API_KEY="your-key"
+4. Or add to config.yaml:
+   llm:
+     provider: groq
+     api_key: "your-key"
+     model: llama-3.3-70b-versatile
+
+Free tier: Up to 14,400 requests/day (model dependent)
+Note: Groq is EXTREMELY fast - responses in milliseconds!
+"""

ai_code_assistant/providers/ollama.py

@@ -0,0 +1,86 @@
+"""Ollama provider for local LLM inference."""
+
+from langchain_core.language_models import BaseChatModel
+from langchain_ollama import ChatOllama
+
+from ai_code_assistant.providers.base import (
+    BaseProvider,
+    ModelInfo,
+    ProviderConfig,
+    ProviderType,
+)
+
+
+class OllamaProvider(BaseProvider):
+    """Provider for Ollama local LLM inference."""
+
+    provider_type = ProviderType.OLLAMA
+    display_name = "Ollama (Local)"
+    requires_api_key = False
+    default_model = "deepseek-coder:6.7b"
+    free_tier = True
+
+    available_models = [
+        ModelInfo(
+            name="deepseek-coder:6.7b",
+            provider=ProviderType.OLLAMA,
+            description="DeepSeek Coder 6.7B - Great for code tasks",
+            context_window=16384,
+            is_free=True,
+        ),
+        ModelInfo(
+            name="codellama:7b",
+            provider=ProviderType.OLLAMA,
+            description="Code Llama 7B - Meta's code model",
+            context_window=16384,
+            is_free=True,
+        ),
+        ModelInfo(
+            name="llama3.1:8b",
+            provider=ProviderType.OLLAMA,
+            description="Llama 3.1 8B - General purpose",
+            context_window=128000,
+            is_free=True,
+        ),
+        ModelInfo(
+            name="qwen2.5-coder:7b",
+            provider=ProviderType.OLLAMA,
+            description="Qwen 2.5 Coder 7B - Excellent for code",
+            context_window=32768,
+            is_free=True,
+        ),
+        ModelInfo(
+            name="mistral:7b",
+            provider=ProviderType.OLLAMA,
+            description="Mistral 7B - Fast and capable",
+            context_window=32768,
+            is_free=True,
+        ),
+    ]
+
+    def _create_llm(self) -> BaseChatModel:
+        """Create Ollama LLM instance."""
+        return ChatOllama(
+            model=self.config.model,
+            base_url=self.config.base_url or "http://localhost:11434",
+            temperature=self.config.temperature,
+            num_predict=self.config.max_tokens,
+            timeout=self.config.timeout,
+        )
+
+    def validate_config(self) -> tuple[bool, str]:
+        """Validate Ollama configuration."""
+        if not self.config.model:
+            return False, "Model name is required"
+        return True, ""
+
+    @classmethod
+    def get_setup_instructions(cls) -> str:
+        """Get Ollama setup instructions."""
+        return """
+Ollama Setup Instructions:
+1. Install Ollama: https://ollama.ai
+2. Pull a model: ollama pull deepseek-coder:6.7b
+3. Start Ollama: ollama serve
+4. No API key required - runs completely locally!
+"""

ai_code_assistant/providers/openai.py

@@ -0,0 +1,114 @@
+"""OpenAI provider for GPT models."""
+
+import os
+from langchain_core.language_models import BaseChatModel
+
+from ai_code_assistant.providers.base import (
+    BaseProvider,
+    ModelInfo,
+    ProviderConfig,
+    ProviderType,
+)
+
+
+class OpenAIProvider(BaseProvider):
+    """Provider for OpenAI GPT models."""
+
+    provider_type = ProviderType.OPENAI
+    display_name = "OpenAI"
+    requires_api_key = True
+    default_model = "gpt-4o-mini"
+    free_tier = False
+
+    available_models = [
+        ModelInfo(
+            name="gpt-4o-mini",
+            provider=ProviderType.OPENAI,
+            description="GPT-4o Mini - Fast and affordable",
+            context_window=128000,
+            is_free=False,
+        ),
+        ModelInfo(
+            name="gpt-4o",
+            provider=ProviderType.OPENAI,
+            description="GPT-4o - Most capable",
+            context_window=128000,
+            is_free=False,
+        ),
+        ModelInfo(
+            name="gpt-4-turbo",
+            provider=ProviderType.OPENAI,
+            description="GPT-4 Turbo - Fast GPT-4",
+            context_window=128000,
+            is_free=False,
+        ),
+        ModelInfo(
+            name="gpt-3.5-turbo",
+            provider=ProviderType.OPENAI,
+            description="GPT-3.5 Turbo - Fast and cheap",
+            context_window=16385,
+            is_free=False,
+        ),
+        ModelInfo(
+            name="o1-mini",
+            provider=ProviderType.OPENAI,
+            description="o1-mini - Reasoning model",
+            context_window=128000,
+            is_free=False,
+        ),
+    ]
+
+    def _create_llm(self) -> BaseChatModel:
+        """Create OpenAI LLM instance."""
+        try:
+            from langchain_openai import ChatOpenAI
+        except ImportError:
+            raise ImportError(
+                "langchain-openai is required for OpenAI provider. "
+                "Install with: pip install langchain-openai"
+            )
+
+        api_key = self.config.api_key or os.getenv("OPENAI_API_KEY")
+        if not api_key:
+            raise ValueError(
+                "OpenAI API key is required. Set OPENAI_API_KEY environment variable "
+                "or provide api_key in config. Get your key at: https://platform.openai.com/api-keys"
+            )
+
+        return ChatOpenAI(
+            model=self.config.model,
+            api_key=api_key,
+            base_url=self.config.base_url,  # Allow custom base URL for Azure, etc.
+            temperature=self.config.temperature,
+            max_tokens=self.config.max_tokens,
+            timeout=self.config.timeout,
+        )
+
+    def validate_config(self) -> tuple[bool, str]:
+        """Validate OpenAI configuration."""
+        api_key = self.config.api_key or os.getenv("OPENAI_API_KEY")
+        if not api_key:
+            return False, "OPENAI_API_KEY environment variable or api_key config is required"
+        if not self.config.model:
+            return False, "Model name is required"
+        return True, ""
+
+    @classmethod
+    def get_setup_instructions(cls) -> str:
+        """Get OpenAI setup instructions."""
+        return """
+OpenAI Setup Instructions:
+1. Go to https://platform.openai.com/api-keys
+2. Create an API key (requires payment method)
+3. Set environment variable: export OPENAI_API_KEY="your-key"
+4. Or add to config.yaml:
+   llm:
+     provider: openai
+     api_key: "your-key"
+     model: gpt-4o-mini
+
+Note: OpenAI requires a paid account. Consider using free alternatives:
+- Groq (free tier with Llama models)
+- Google AI Studio (free tier with Gemini)
+- OpenRouter (free tier with various models)
+"""

ai_code_assistant/providers/openrouter.py

@@ -0,0 +1,130 @@
+"""OpenRouter provider for access to multiple LLM providers."""
+
+import os
+from langchain_core.language_models import BaseChatModel
+
+from ai_code_assistant.providers.base import (
+    BaseProvider,
+    ModelInfo,
+    ProviderConfig,
+    ProviderType,
+)
+
+
+class OpenRouterProvider(BaseProvider):
+    """Provider for OpenRouter - access to multiple LLM providers."""
+
+    provider_type = ProviderType.OPENROUTER
+    display_name = "OpenRouter (Multi-Provider)"
+    requires_api_key = True
+    default_model = "meta-llama/llama-3.3-70b-instruct:free"
+    free_tier = True
+
+    available_models = [
+        ModelInfo(
+            name="meta-llama/llama-3.3-70b-instruct:free",
+            provider=ProviderType.OPENROUTER,
+            description="Llama 3.3 70B - Free tier",
+            context_window=128000,
+            is_free=True,
+        ),
+        ModelInfo(
+            name="google/gemma-3-27b-it:free",
+            provider=ProviderType.OPENROUTER,
+            description="Gemma 3 27B - Free tier",
+            context_window=8192,
+            is_free=True,
+        ),
+        ModelInfo(
+            name="mistralai/mistral-small-3.1-24b-instruct:free",
+            provider=ProviderType.OPENROUTER,
+            description="Mistral Small 3.1 - Free tier",
+            context_window=32768,
+            is_free=True,
+        ),
+        ModelInfo(
+            name="qwen/qwen3-4b:free",
+            provider=ProviderType.OPENROUTER,
+            description="Qwen 3 4B - Free tier, fast",
+            context_window=32768,
+            is_free=True,
+        ),
+        ModelInfo(
+            name="deepseek/deepseek-r1:free",
+            provider=ProviderType.OPENROUTER,
+            description="DeepSeek R1 - Reasoning model, free",
+            context_window=64000,
+            is_free=True,
+        ),
+        ModelInfo(
+            name="anthropic/claude-3.5-sonnet",
+            provider=ProviderType.OPENROUTER,
+            description="Claude 3.5 Sonnet - Paid, excellent for code",
+            context_window=200000,
+            is_free=False,
+        ),
+        ModelInfo(
+            name="openai/gpt-4o",
+            provider=ProviderType.OPENROUTER,
+            description="GPT-4o - Paid, OpenAI's best",
+            context_window=128000,
+            is_free=False,
+        ),
+    ]
+
+    def _create_llm(self) -> BaseChatModel:
+        """Create OpenRouter LLM instance using OpenAI-compatible API."""
+        try:
+            from langchain_openai import ChatOpenAI
+        except ImportError:
+            raise ImportError(
+                "langchain-openai is required for OpenRouter provider. "
+                "Install with: pip install langchain-openai"
+            )
+
+        api_key = self.config.api_key or os.getenv("OPENROUTER_API_KEY")
+        if not api_key:
+            raise ValueError(
+                "OpenRouter API key is required. Set OPENROUTER_API_KEY environment variable "
+                "or provide api_key in config. Get your key at: https://openrouter.ai/keys"
+            )
+
+        return ChatOpenAI(
+            model=self.config.model,
+            api_key=api_key,
+            base_url="https://openrouter.ai/api/v1",
+            temperature=self.config.temperature,
+            max_tokens=self.config.max_tokens,
+            timeout=self.config.timeout,
+            default_headers={
+                "HTTP-Referer": "https://github.com/akkssy/cognify-ai",
+                "X-Title": "Cognify AI",
+            },
+        )
+
+    def validate_config(self) -> tuple[bool, str]:
+        """Validate OpenRouter configuration."""
+        api_key = self.config.api_key or os.getenv("OPENROUTER_API_KEY")
+        if not api_key:
+            return False, "OPENROUTER_API_KEY environment variable or api_key config is required"
+        if not self.config.model:
+            return False, "Model name is required"
+        return True, ""
+
+    @classmethod
+    def get_setup_instructions(cls) -> str:
+        """Get OpenRouter setup instructions."""
+        return """
+OpenRouter Setup Instructions:
+1. Go to https://openrouter.ai/keys
+2. Create a free account and generate an API key
+3. Set environment variable: export OPENROUTER_API_KEY="your-key"
+4. Or add to config.yaml:
+   llm:
+     provider: openrouter
+     api_key: "your-key"
+     model: meta-llama/llama-3.3-70b-instruct:free
+
+Free tier: 50 requests/day on free models (models ending with :free)
+Paid: Access to GPT-4, Claude, and many more models
+"""