h-ai-brain 0.0.23__py3-none-any.whl → 0.0.24__py3-none-any.whl

h_ai/infrastructure/llm/json_resource_loader.py

@@ -0,0 +1,97 @@
+import os
+import json
+import importlib.util
+import importlib.resources
+from typing import Dict, Any
+
+
+class JsonResourceLoader:
+    """
+    Loader for JSON configuration files.
+
+    This class provides functionality to load JSON configuration files from the resources directory.
+    It can load files from either a package or the file system, with fallback behavior.
+
+    Usage:
+        # Create a JSON resource loader
+        loader = JsonResourceLoader()
+
+        # Load a JSON resource
+        config = loader.load_json_resource("autonomous_agent.json")
+    """
+
+    def __init__(self, resources_dir: str = None, package_name: str = None, resources_path: str = None):
+        """
+        Initialize a new JsonResourceLoader.
+
+        Args:
+            resources_dir: Directory containing JSON resources. If None, defaults to 'resources'.
+            package_name: Python package name containing resources. If None, defaults to 'h_ai'.
+            resources_path: Path within the package to resources. If None, defaults to 'resources'.
+        """
+        # Get the base directory of the package
+        base_dir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+        # Set default directories if not provided
+        if resources_dir is None:
+            resources_dir = os.path.join(base_dir, 'resources')
+        if package_name is None:
+            package_name = 'h_ai'
+        if resources_path is None:
+            resources_path = 'resources'
+
+        self.resources_dir = resources_dir
+        self.package_name = package_name
+        self.resources_path = resources_path
+
+    def load_json_resource(self, filename: str) -> Dict[str, Any]:
+        """
+        Load a JSON resource file from package or file system.
+
+        Args:
+            filename: Name of the JSON file (with or without .json extension).
+
+        Returns:
+            Dict[str, Any]: The loaded JSON data.
+
+        Raises:
+            ValueError: If the resource file cannot be found in either the package or file system.
+        """
+        # Add .json extension if not present
+        if not filename.endswith('.json'):
+            filename = f"{filename}.json"
+
+        # First try to load from package
+        try:
+            # Construct the resource path within the package
+            resource_path = os.path.join(self.resources_path, filename)
+            resource_path = resource_path.replace('\\', '/')  # Ensure forward slashes for package paths
+
+            # Try to get the resource from the package
+            package_spec = importlib.util.find_spec(self.package_name)
+            if package_spec is not None:
+                # Use importlib.resources to get the resource content
+                resource_package = f"{self.package_name}.{os.path.dirname(resource_path)}"
+                resource_name = os.path.basename(resource_path)
+
+                # Handle different importlib.resources APIs based on Python version
+                try:
+                    # Python 3.9+
+                    with importlib.resources.files(resource_package).joinpath(resource_name).open('r') as f:
+                        return json.load(f)
+                except (AttributeError, ImportError):
+                    # Fallback for older Python versions
+                    resource_text = importlib.resources.read_text(resource_package, resource_name)
+                    return json.loads(resource_text)
+        except (ImportError, ModuleNotFoundError, FileNotFoundError, ValueError):
+            # If package loading fails, fall back to file system
+            pass
+
+        # Fall back to file system
+        file_path = os.path.join(self.resources_dir, filename)
+        if os.path.exists(file_path):
+            with open(file_path, 'r') as f:
+                return json.load(f)
+
+        # If we get here, the resource wasn't found in either location
+        raise ValueError(f"Resource file not found: {filename} (tried package '{self.package_name}' and directory '{self.resources_dir}')")

h_ai/infrastructure/llm/ollama/factories/__init__.py

@@ -0,0 +1 @@
+# This file is intentionally left empty to mark the directory as a Python package.

h_ai/infrastructure/llm/ollama/factories/granite_factory.py

@@ -0,0 +1,91 @@
+from typing import Optional
+
+from .....domain.model_factory import ModelFactory
+from .....domain.reasoning.llm_chat_repository import LlmChatRepository
+from .....domain.reasoning.llm_embedding_repository import LlmEmbeddingRepository
+from .....domain.reasoning.llm_generate_respository import LlmGenerateRepository
+from ....llm.template_loader import TemplateLoader
+from ..ollama_chat_repository import OllamaChatRepository
+from ..ollama_generate_repository import OllamaGenerateRepository
+
+
+class GraniteModelFactory(ModelFactory):
+    """
+    Factory for creating repositories for the Granite 3.3:8b model.
+    """
+
+    MODEL_NAME = "granite3.3:8b"
+
+    def __init__(self, api_url: str, temperature: float = 0.6, max_tokens: int = 2500, 
+                 api_token: str = None, use_templating: bool = True):
+        """
+        Initialize a new GraniteModelFactory.
+
+        Args:
+            api_url: The base URL of the Ollama API.
+            temperature: The temperature to use for generation.
+            max_tokens: The maximum number of tokens to generate.
+            api_token: Optional API token for authentication.
+            use_templating: Whether to use Jinja2 templating for prompt formatting.
+        """
+        self.api_url = api_url
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+        self.api_token = api_token
+        self.use_templating = use_templating
+
+        # Create a template loader if templating is enabled
+        if use_templating:
+            self.template_loader = TemplateLoader()
+
+    def create_chat_repository(self) -> LlmChatRepository:
+        """
+        Creates a chat repository for the Granite model.
+
+        Returns:
+            LlmChatRepository: A repository for chat interactions with the Granite model.
+        """
+        kwargs = {
+            "api_url": self.api_url,
+            "model_name": self.MODEL_NAME,
+            "temperature": self.temperature,
+            "api_token": self.api_token,
+            "use_templating": self.use_templating
+        }
+
+        # Add template loader if templating is enabled
+        if self.use_templating and hasattr(self, 'template_loader'):
+            kwargs["template_loader"] = self.template_loader
+
+        return OllamaChatRepository(**kwargs)
+
+    def create_generate_repository(self) -> LlmGenerateRepository:
+        """
+        Creates a generate repository for the Granite model.
+
+        Returns:
+            LlmGenerateRepository: A repository for text generation with the Granite model.
+        """
+        kwargs = {
+            "api_url": self.api_url,
+            "model_name": self.MODEL_NAME,
+            "temperature": self.temperature,
+            "max_tokens": self.max_tokens,
+            "api_token": self.api_token,
+            "use_templating": self.use_templating
+        }
+
+        # Add template loader if templating is enabled
+        if self.use_templating and hasattr(self, 'template_loader'):
+            kwargs["template_loader"] = self.template_loader
+
+        return OllamaGenerateRepository(**kwargs)
+
+    def create_embedding_repository(self) -> Optional[LlmEmbeddingRepository]:
+        """
+        Granite model doesn't support embeddings, so this returns None.
+
+        Returns:
+            Optional[LlmEmbeddingRepository]: None, as Granite doesn't support embeddings.
+        """
+        return None

h_ai/infrastructure/llm/ollama/factories/nomic_factory.py

@@ -0,0 +1,58 @@
+from typing import Optional
+
+from .....domain.model_factory import ModelFactory
+from .....domain.reasoning.llm_chat_repository import LlmChatRepository
+from .....domain.reasoning.llm_embedding_repository import LlmEmbeddingRepository
+from .....domain.reasoning.llm_generate_respository import LlmGenerateRepository
+from ..ollama_embed_repository import OllamaEmbeddingRepository
+
+
+class NomicModelFactory(ModelFactory):
+    """
+    Factory for creating repositories for the Nomic Embed Text model.
+    This model is specifically for embeddings and doesn't support chat or generation.
+    """
+    
+    MODEL_NAME = "nomic-embed-text:137m-v1.5-fp16"
+    
+    def __init__(self, api_url: str, api_token: str = None):
+        """
+        Initialize a new NomicModelFactory.
+        
+        Args:
+            api_url: The base URL of the Ollama API.
+            api_token: Optional API token for authentication.
+        """
+        self.api_url = api_url
+        self.api_token = api_token
+    
+    def create_chat_repository(self) -> Optional[LlmChatRepository]:
+        """
+        Nomic model doesn't support chat, so this returns None.
+        
+        Returns:
+            Optional[LlmChatRepository]: None, as Nomic doesn't support chat.
+        """
+        return None
+    
+    def create_generate_repository(self) -> Optional[LlmGenerateRepository]:
+        """
+        Nomic model doesn't support generation, so this returns None.
+        
+        Returns:
+            Optional[LlmGenerateRepository]: None, as Nomic doesn't support generation.
+        """
+        return None
+    
+    def create_embedding_repository(self) -> LlmEmbeddingRepository:
+        """
+        Creates an embedding repository for the Nomic model.
+        
+        Returns:
+            LlmEmbeddingRepository: A repository for creating embeddings with the Nomic model.
+        """
+        return OllamaEmbeddingRepository(
+            api_url=self.api_url,
+            model_name=self.MODEL_NAME,
+            api_token=self.api_token
+        )

h_ai/infrastructure/llm/ollama/ollama_chat_repository.py

@@ -1,56 +1,195 @@
-from typing import Optional, List
-
-import requests
+from typing import Optional, List, Dict, Any
 
 from ....domain.reasoning.llm_chat_repository import LlmChatRepository
 from ....infrastructure.llm.llm_response_cleaner import clean_llm_response
 from ....infrastructure.llm.ollama.models.ollama_chat_message import OllamaChatMessage
 from ....infrastructure.llm.ollama.models.ollama_chat_session import OllamaChatSession
+from ....infrastructure.llm.template_loader import TemplateLoader
+from .ollama_http_client import OllamaHttpClient
 
 
 class OllamaChatRepository(LlmChatRepository):
+    """
+    Repository for chat interactions using the Ollama API.
+    """
+
+    def __init__(self, api_url: str, model_name: str, system_prompts: list[str] = None, 
+                 temperature: float = None, seed: int = None, api_token: str = None,
+                 template_loader: TemplateLoader = None, use_templating: bool = True):
+        """
+        Initialize a new OllamaChatRepository.
 
-    def __init__(self, api_url: str, model_name: str, system_prompts: list[str] = None, temperature: float = None, seed: int = None):
-        self.api_url = api_url
+        Args:
+            api_url: The base URL of the Ollama API.
+            model_name: The name of the model to use.
+            system_prompts: Optional list of system prompts to use for the chat.
+            temperature: The temperature to use for generation.
+            seed: Optional seed for reproducible generation.
+            api_token: Optional API token for authentication.
+            template_loader: Optional template loader to use for formatting prompts.
+            use_templating: Whether to use Jinja2 templating for prompt formatting.
+        """
         self.model_name = model_name
         self.temperature = temperature
         self.seed = seed
-        self.system_prompts = system_prompts
+        self.system_prompts = system_prompts or []
+        self.http_client = OllamaHttpClient(api_url, api_token)
+        self.use_templating = use_templating
+
+        # Initialize template loader if not provided and templating is enabled
+        if use_templating:
+            self.template_loader = template_loader or TemplateLoader()
+
+    def chat(self, user_message: str, session_id: str, chat_history: List[dict] = None) -> Optional[str]:
+        """
+        Chat with the model using the Ollama API.
 
-    def chat(self, user_message: str, session_id: str) -> Optional[str]:
+        Args:
+            user_message: The user's message.
+            session_id: The ID of the chat session.
+            chat_history: Optional chat history to include in the conversation.
 
-        messages = [OllamaChatMessage("user", user_message)]
+        Returns:
+            Optional[str]: The model's response, or None if the request failed.
+        """
+        # Start with system prompts and user message
+        messages = []
         for system_prompt in self.system_prompts:
             messages.append(OllamaChatMessage("system", system_prompt))
+
+        # Add chat history if provided
+        if chat_history:
+            for message in chat_history:
+                messages.append(OllamaChatMessage(message.get("role", "user"), message.get("content", "")))
+
+        # Add the current user message
+        messages.append(OllamaChatMessage("user", user_message))
+
+        # Create a session
         session = OllamaChatSession(session_id, messages)
 
-        return self._call_ollama_api(session.messages)
+        return self.chat_with_messages(session.messages)
+
+    def chat_with_messages(self, messages: List[Any]) -> Optional[str]:
+        """
+        Chat with the model using a custom list of messages.
+
+        This method allows for more flexibility in message formatting, such as including
+        document messages or other special message types.
+
+        Args:
+            messages: The list of messages to send to the model. Each message should have
+                     'role' and 'content' attributes or keys.
+
+        Returns:
+            Optional[str]: The model's response, or None if the request failed.
+        """
+        return self._call_ollama_api(messages)
+
+    def _format_with_template(self, messages: List[Any]) -> str:
+        """
+        Format messages using a Jinja2 template appropriate for the model.
+
+        Args:
+            messages: The messages to format. Each message should have 'role' and 'content' attributes.
+
+        Returns:
+            str: The formatted prompt string.
+        """
+        # Get the appropriate template for this model
+        template_name = self.template_loader.get_model_template(self.model_name)
+        if not template_name:
+            # Fall back to standard formatting if no template is available
+            return self._format_standard(messages)
 
-    def _call_ollama_api(self, messages: List[OllamaChatMessage]) -> Optional[str]:
-        url = f"{self.api_url}/chat"
-        formatted_messages = [message.to_dict() for message in messages]
+        # Extract system messages
+        system_content = ""
+        for msg in messages:
+            if msg.role == "system":
+                if system_content:
+                    system_content += "\n\n"
+                system_content += msg.content
+
+        # Prepare context for the template
+        context = {
+            "System": system_content,
+            "Messages": [{"Role": msg.role, "Content": msg.content} for msg in messages],
+            "Tools": []  # Can be extended later to support tools
+        }
+
+        # Render the template
+        return self.template_loader.render_template(template_name, context)
+
+    def _format_standard(self, messages: List[Any]) -> List[Dict[str, str]]:
+        """
+        Format messages in the standard Ollama API format.
+
+        Args:
+            messages: The messages to format. Each message should have 'role' and 'content' attributes.
+
+        Returns:
+            List[Dict[str, str]]: The formatted messages.
+        """
+        result = []
+        for message in messages:
+            # Handle OllamaChatMessage objects
+            if hasattr(message, 'to_dict'):
+                result.append(message.to_dict())
+            # Handle dict-like objects
+            elif hasattr(message, 'get'):
+                result.append({
+                    "role": message.get("role", "user"),
+                    "content": message.get("content", "")
+                })
+            # Handle objects with role and content attributes
+            else:
+                result.append({
+                    "role": getattr(message, "role", "user"),
+                    "content": getattr(message, "content", "")
+                })
+        return result
+
+    def _call_ollama_api(self, messages: List[Any]) -> Optional[str]:
+        """
+        Call the Ollama API with the given messages.
+
+        Args:
+            messages: The messages to send to the API. Each message should have 'role' and 'content' attributes.
+
+        Returns:
+            Optional[str]: The model's response, or None if the request failed.
+        """
         payload = {
             "model": self.model_name,
-            "messages": formatted_messages,
-            "stream": False,
-            "temperature": "0.6"
+            "stream": False
         }
+
+        # Add temperature and seed if provided
         if self.temperature:
             payload["temperature"] = self.temperature
         if self.seed:
             payload["seed"] = self.seed
 
-        try:
-            print(payload)
-            response = requests.post(url, json=payload)
-            response.raise_for_status()
-            full_response = response.json()["message"]["content"]
-            print(full_response)
-            return clean_llm_response(full_response)
-
-        except requests.exceptions.RequestException as e:
-            print(f"Error occurred during API call: {e}")
-            return None
+        # Use templating if enabled and available for this model
+        if self.use_templating and hasattr(self, 'template_loader'):
+            # Format with template and use the prompt API
+            formatted_prompt = self._format_with_template(messages)
+            payload["prompt"] = formatted_prompt
+            endpoint = "generate"
+        else:
+            # Use standard message formatting and the chat API
+            payload["messages"] = self._format_standard(messages)
+            endpoint = "chat"
 
+        # Call the appropriate API endpoint
+        response_data = self.http_client.post(endpoint, payload)
+        if response_data:
+            # Extract response based on the endpoint used
+            if endpoint == "generate":
+                full_response = response_data.get("response")
+            else:
+                full_response = response_data.get("message", {}).get("content")
 
+            return clean_llm_response(full_response)
 
+        return None

h_ai/infrastructure/llm/ollama/ollama_embed_repository.py

@@ -0,0 +1,43 @@
+from typing import Optional, List
+
+from ....domain.reasoning.llm_embedding_repository import LlmEmbeddingRepository
+from .ollama_http_client import OllamaHttpClient
+
+
+class OllamaEmbeddingRepository(LlmEmbeddingRepository):
+    """
+    Repository for creating embeddings using the Ollama API.
+    """
+
+    def __init__(self, api_url: str, model_name: str, api_token: str = None):
+        """
+        Initialize a new OllamaEmbeddingRepository.
+
+        Args:
+            api_url: The base URL of the Ollama API.
+            model_name: The name of the model to use.
+            api_token: Optional API token for authentication.
+        """
+        self.model_name = model_name
+        self.http_client = OllamaHttpClient(api_url, api_token)
+
+    def embed(self, text: str) -> Optional[List[float]]:
+        """
+        Create an embedding for the given text using the Ollama API.
+
+        Args:
+            text: The text to create an embedding for.
+
+        Returns:
+            Optional[List[float]]: The embedding vector, or None if the request failed.
+        """
+        payload = {
+            "model": self.model_name,
+            "prompt": text
+        }
+
+        response_data = self.http_client.post("embeddings", payload)
+        if response_data:
+            return response_data.get("embedding")
+
+        return None

h_ai/infrastructure/llm/ollama/ollama_generate_repository.py

@@ -1,40 +1,98 @@
 import uuid
-
-import requests
+from typing import Optional, Dict, Any, List
 
 from ..llm_response_cleaner import clean_llm_response
+from ..template_loader import TemplateLoader
 from ....domain.reasoning.llm_generate_respository import LlmGenerateRepository
+from .ollama_http_client import OllamaHttpClient
 
 
 class OllamaGenerateRepository(LlmGenerateRepository):
+    """
+    Repository for generating text using the Ollama API.
+    """
+
+    def __init__(self, api_url: str, model_name: str, system_prompt: str = None, 
+                 temperature: float = None, seed: int = None, max_tokens: int = 5000, 
+                 api_token: str = None, template_loader: TemplateLoader = None, 
+                 use_templating: bool = True):
+        """
+        Initialize a new OllamaGenerateRepository.
 
-    def __init__(self, api_url: str, model_name: str, system_prompt: str = None, temperature: float = None, seed: int = None, max_tokens: int = 5000, api_token: str = None):
+        Args:
+            api_url: The base URL of the Ollama API.
+            model_name: The name of the model to use.
+            system_prompt: Optional system prompt to use for generation.
+            temperature: The temperature to use for generation.
+            seed: Optional seed for reproducible generation.
+            max_tokens: The maximum number of tokens to generate.
+            api_token: Optional API token for authentication.
+            template_loader: Optional template loader to use for formatting prompts.
+            use_templating: Whether to use Jinja2 templating for prompt formatting.
+        """
         self.model_name = model_name
         self.system_prompt = system_prompt
-        self.api_url = api_url
         self.temperature = temperature
         self.seed = seed
         self.max_tokens = max_tokens
-        self.api_token = api_token
+        self.http_client = OllamaHttpClient(api_url, api_token)
+        self.use_templating = use_templating
+
+        # Initialize template loader if not provided and templating is enabled
+        if use_templating:
+            self.template_loader = template_loader or TemplateLoader()
+
+    def _format_with_template(self, user_prompt: str, system_prompt: str = None) -> str:
+        """
+        Format the prompt using a Jinja2 template appropriate for the model.
+
+        Args:
+            user_prompt: The user's prompt.
+            system_prompt: Optional system prompt.
+
+        Returns:
+            str: The formatted prompt string.
+        """
+        # Get the appropriate template for this model
+        template_name = self.template_loader.get_model_template(self.model_name)
+        if not template_name:
+            # If no template is available, return the user prompt with system prompt as prefix
+            if system_prompt:
+                return f"{system_prompt}\n\n{user_prompt}"
+            return user_prompt
+
+        # Prepare context for the template
+        context = {
+            "System": system_prompt or "",
+            "Messages": [
+                {"Role": "user", "Content": user_prompt}
+            ],
+            "Tools": []  # Can be extended later to support tools
+        }
+
+        # Render the template
+        return self.template_loader.render_template(template_name, context)
 
+    def generate(self, user_prompt: str, system_prompt: str = None, max_tokens: int = None) -> Optional[str]:
+        """
+        Generate text using the Ollama API.
 
-    def generate(self, user_prompt: str, system_prompt: str = None, session_id: str = None, max_tokens: int = None) -> str|None:
-        url = f"{self.api_url}/generate"
-        random_guid = uuid.uuid4()
-        guid_str = str(random_guid)
+        Args:
+            user_prompt: The prompt to generate text from.
+            system_prompt: Optional system prompt to override the default.
+            max_tokens: Optional maximum number of tokens to generate.
+
+        Returns:
+            Optional[str]: The generated text, or None if the request failed.
+        """
         system_prompt = system_prompt or self.system_prompt
         payload = {
             "model": self.model_name,
-            "prompt": user_prompt,
-            "system": system_prompt,
             "stream": False,
-            "session": guid_str,
-            "num_ctx": f"{self.max_tokens}",
-            "temperature": f"{self.temperature}"
+            "num_ctx": f"{self.max_tokens}"
         }
 
-        if session_id:
-            payload["session"] = session_id
+        # Add common parameters
         if self.seed:
             payload["seed"] = f"{self.seed}"
         if self.temperature:
@@ -42,22 +100,20 @@ class OllamaGenerateRepository(LlmGenerateRepository):
         if max_tokens:
             payload["num_ctx"] = f"{max_tokens}"
 
-        headers = {}
-        if self.api_token:
-            headers["Authorization"]="Bearer "+self.api_token
-
-        try:
-            #print(payload)
-            response = requests.post(url, json=payload, headers=headers)
+        # Use templating if enabled and available for this model
+        if self.use_templating and hasattr(self, 'template_loader'):
+            # Format with template
+            formatted_prompt = self._format_with_template(user_prompt, system_prompt)
+            payload["prompt"] = formatted_prompt
+        else:
+            # Use standard formatting
+            payload["prompt"] = user_prompt
+            if system_prompt:
+                payload["system"] = system_prompt
 
-            response.raise_for_status()
-
-            #print(response.json())
-
-            response_content = response.json()["response"]
+        response_data = self.http_client.post("generate", payload)
+        if response_data:
+            response_content = response_data.get("response")
             return clean_llm_response(response_content)
 
-        except requests.exceptions.RequestException as e:
-            print(f"Error occurred during API call: {e}")
-            return None
-
+        return None