llm-interface 0.1.0__py3-none-any.whl

llm_interface/__init__.py

@@ -0,0 +1,6 @@
+from .llm_config import llm_from_config
+from .llm_interface import LLMInterface
+from .llm_tool import tool
+
+__version__ = "0.1.0"
+__all__ = ["LLMInterface", "llm_from_config", "tool"]

llm_interface/anthropic.py

@@ -0,0 +1,194 @@
+# Copyright 2024 Niels Provos
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import Any, Dict, List, Optional
+
+from anthropic import Anthropic, APIError
+
+
+def translate_tools_for_anthropic(tools: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """
+    Translate a list of tools from Ollama/API format to Anthropic format.
+
+    Args:
+        tools (List[Tool]): List of tool objects from the Ollama/API.
+
+    Returns:
+        List[Dict[str, Any]]: Translated tools ready for Anthropic API consumption.
+    """
+    anthropic_tools = []
+
+    for tool in tools:
+        # Extract the function from the tool
+        function = tool["function"]
+
+        # Assuming Tool objects have keys 'name', 'description', and 'parameters' which is a dict
+        translated_tool = {
+            "name": function["name"],
+            "description": function["description"],
+            "input_schema": {
+                "type": "object",
+                "properties": function["parameters"]["properties"],
+                "required": function["parameters"]["required"],
+            },
+        }
+        anthropic_tools.append(translated_tool)
+
+    return anthropic_tools
+
+
+def translate_messages_for_anthropic(
+    messages: List[Dict[str, Any]]
+) -> List[Dict[str, Any]]:
+    """
+    Translate messages from Ollama/API format to Anthropic format.
+
+    Args:
+        messages (List[Dict[str, Any]]): List of message dictionaries in Ollama format
+
+    Returns:
+        List[Dict[str, Any]]: Translated messages in Anthropic format
+    """
+    translated_messages = []
+
+    for msg in messages:
+        if msg["role"] == "user":
+            # Regular user messages pass through unchanged
+            translated_messages.append({"role": "user", "content": msg["content"]})
+
+        elif msg["role"] == "assistant" and "tool_calls" in msg:
+            # Convert assistant tool calls to Anthropic format
+            tool_call = msg["tool_calls"][0]  # Assume single tool call for now
+            translated_messages.append(
+                {
+                    "role": "assistant",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": f"<thinking>I need to use {tool_call['function']['name']} to help answer this question.</thinking>",
+                        },
+                        {
+                            "type": "tool_use",
+                            "id": tool_call["id"],
+                            "name": tool_call["function"]["name"],
+                            "input": tool_call["function"]["arguments"],
+                        },
+                    ],
+                }
+            )
+
+        elif msg["role"] == "tool":
+            # Convert tool response to Anthropic's tool_result format
+            translated_messages.append(
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "tool_result",
+                            "tool_use_id": msg["tool_call_id"],
+                            "content": msg["content"],
+                        }
+                    ],
+                }
+            )
+        else:
+            raise ValueError(f"Unknown message role: {msg['role']}")
+
+    return translated_messages
+
+
+class AnthropicWrapper:
+    def __init__(self, api_key: str, max_tokens: int = 4096):
+        self.client = Anthropic(api_key=api_key)
+        self.max_tokens = max_tokens
+
+    def chat(
+        self,
+        messages: List[Dict[str, str]],
+        tools: Optional[List[Dict[str, Any]]] = None,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """
+        Conduct a chat conversation using the Anthropic API.
+
+        Args:
+            messages (list[Mapping[str, str]]): A list of message dictionaries, each containing 'role' and 'content'.
+            **kwargs: Additional arguments to pass to the generate function.
+
+        Returns:
+            A dictionary containing the Anthropic response formatted to match Ollama's expected output.
+        """
+        # Extract the system message from the messages and prepare it as a separate argument
+        system_message = next(
+            (msg["content"] for msg in messages if msg["role"] == "system"), None
+        )
+
+        # Filter out the system message to prevent duplication if it's not needed in the messages parameter
+        filtered_messages = [msg for msg in messages if msg["role"] != "system"]
+
+        # Translate messages into Anthropic format
+        if any(msg["role"] == "tool" for msg in filtered_messages):
+            filtered_messages = translate_messages_for_anthropic(filtered_messages)
+
+        # Common parameters
+        params = {
+            "max_tokens": kwargs.get("max_tokens", self.max_tokens),
+            "messages": filtered_messages,
+            "model": kwargs.get("model", "claude-3-5-sonnet-20240620"),
+            "system": system_message,  # Pass the system message here
+        }
+
+        # Conditionally add temperature if it exists in kwargs
+        if "options" in kwargs:
+            if "temperature" in kwargs["options"]:
+                params["temperature"] = kwargs["options"]["temperature"]
+
+        if tools:
+            # Translate tools into Anthropic format
+            anthropic_tools = translate_tools_for_anthropic(tools)
+            params["tools"] = anthropic_tools
+
+        try:
+            # Call the function with the constructed parameters
+            response = self.client.messages.create(**params)
+
+            # Handle tool calls if present
+            if any(block.type == "tool_use" for block in response.content):
+                # Find all tool use blocks
+                tool_use_blocks = [
+                    block for block in response.content if block.type == "tool_use"
+                ]
+
+                return {
+                    "message": {
+                        "content": "",
+                        "tool_calls": [
+                            {
+                                "id": tool_block.id,
+                                "name": tool_block.name,
+                                "arguments": tool_block.input,  # Anthropic uses 'input' instead of 'arguments'
+                            }
+                            for tool_block in tool_use_blocks
+                        ],
+                    }
+                }
+
+            # Extract content blocks as text and simulate Ollama-like response
+            content = "".join(
+                block.text for block in response.content if block.type == "text"
+            )
+
+            return {"message": {"content": content}}
+
+        except APIError as e:
+            raise e

llm_interface/llm_config.py

@@ -0,0 +1,117 @@
+import os
+from typing import Literal, Optional
+
+from .anthropic import AnthropicWrapper
+from .llm_interface import LLMInterface
+from .openai import OpenAIWrapper
+from .remote_ollama import RemoteOllama
+from .ssh import SSHConnection
+
+
+def llm_from_config(
+    provider: Literal["ollama", "remote_ollama", "openai"] = "ollama",
+    model_name: str = "llama3",
+    max_tokens: int = 4096,
+    host: Optional[str] = None,
+    hostname: Optional[str] = None,
+    username: Optional[str] = None,
+    log_dir: str = "logs",
+    use_cache: bool = True,
+) -> LLMInterface:
+    """
+    Creates and configures a language model interface based on specified provider and parameters.
+
+    This function initializes a LLMInterface instance with the appropriate wrapper/client
+    based on the selected provider (ollama, remote_ollama, openai, or anthropic).
+
+    Args:
+        provider (Literal["ollama", "remote_ollama", "openai"]): The LLM provider to use.
+            Defaults to "ollama".
+        model_name (str): Name of the model to use. Defaults to "llama3".
+        max_tokens (int): Maximum number of tokens for model responses. Defaults to 4096.
+        host (Optional[str]): Host address for local ollama instance. Only used with "ollama" provider.
+        hostname (Optional[str]): Remote hostname for SSH connection. Required for "remote_ollama".
+        username (Optional[str]): Username for SSH connection. Required for "remote_ollama".
+        log_dir (str): Directory for storing logs. Defaults to "logs".
+        use_cache (bool): Whether to cache model responses. Defaults to True.
+
+    Returns:
+        LLMInterface: Configured interface for interacting with the specified LLM.
+
+    Raises:
+        ValueError: If required API keys are not found in environment variables,
+            or if an invalid provider is specified.
+
+    Examples:
+        >>> # Create an OpenAI interface
+        >>> llm = llm_from_config(provider="openai", model_name="gpt-4")
+
+        >>> # Create a local Ollama interface
+        >>> llm = llm_from_config(provider="ollama", model_name="llama2")
+
+        >>> # Create a remote Ollama interface
+        >>> llm = llm_from_config(
+        ...     provider="remote_ollama",
+        ...     hostname="example.com",
+        ...     username="user"
+        ... )
+    """
+    match provider:
+        case "openai":
+            api_key = os.getenv("OPENAI_API_KEY")
+            if api_key is None:
+                raise ValueError("OPENAI_API_KEY not found in environment variables")
+            wrapper = OpenAIWrapper(api_key=api_key, max_tokens=max_tokens)
+            # add gpt-4o once the switch is made
+            support_structured_outputs = model_name in [
+                "gpt-4o-mini",
+                "gpt-4o-mini-2024-07-18",
+                "gpt-4o-2024-08-06",
+                "gpt-4o-2024-11-20",
+                "gpt-4o",
+            ]
+            support_json_mode = model_name not in ["o1-mini", "o1-preview"]
+            support_system_prompt = model_name not in ["o1-mini", "o1-preview"]
+            return LLMInterface(
+                model_name=model_name,
+                log_dir=log_dir,
+                client=wrapper,
+                support_json_mode=support_json_mode,
+                support_structured_outputs=support_structured_outputs,
+                support_system_prompt=support_system_prompt,
+                use_cache=use_cache,
+            )
+        case "anthropic":
+            api_key = os.getenv("ANTHROPIC_API_KEY")
+            if api_key is None:
+                raise ValueError("ANTHROPIC_API_KEY not found in environment variables")
+            wrapper = AnthropicWrapper(api_key=api_key, max_tokens=max_tokens)
+            return LLMInterface(
+                model_name=model_name,
+                log_dir=log_dir,
+                client=wrapper,
+                support_json_mode=False,
+                use_cache=use_cache,
+            )
+        case "ollama" | "remote_ollama":
+            # Enable structured outputs for Llama 3+ models
+            supports_structured = True
+            if provider == "remote_ollama":
+                ssh = SSHConnection(
+                    hostname=hostname,
+                    username=username,
+                )
+                client = RemoteOllama(ssh_connection=ssh, model_name=model_name)
+            else:
+                client = None
+            return LLMInterface(
+                model_name=model_name,
+                log_dir=log_dir,
+                client=client,
+                host=host,
+                support_json_mode=True,
+                support_structured_outputs=supports_structured,
+                use_cache=use_cache,
+            )
+
+    raise ValueError(f"Invalid LLM provider in config: {provider}")