Added anthropic connector. Make ollama, openai, and anthropic optional

Author: travis-bauer

CHANGELOG.md

@@ -3,6 +3,7 @@
 ## 0.9.2 (in development)
 ### Improvements
 - Added ability for sources and segments to have multiple names in chatterlang.
+- Removed signature segments
 
 ## 0.9.1
 Forgot to import the lancedb module in talkpipe/__init__.py, so it wasn't registering the segments.

Dockerfile

@@ -37,7 +37,7 @@ COPY --chown=builder:builder tests/ tests/
 RUN python3 -m pip install --user --upgrade pip setuptools wheel build
 RUN python3 -m pip install --user numpy pandas matplotlib scikit-learn scipy
 ENV SETUPTOOLS_SCM_PRETEND_VERSION_FOR_TALKPIPE=0.1.0
-RUN python3 -m pip install --user -e .[dev]
+RUN python3 -m pip install --user -e .[dev,all]
 RUN python3 -m pytest --log-cli-level=DEBUG
 RUN python3 -m build --wheel
 

pyproject.toml

@@ -24,7 +24,6 @@ dependencies = [
     'prompt_toolkit',
     'parsy',
     'pydantic',
-    'ollama',
     'requests',
     'numpy',
     'numba==0.62.0',
@@ -34,7 +33,6 @@ dependencies = [
     'readability-lxml',
     'lxml',
     'lxml_html_clean',
-    'openai',
     'fastapi[standard]',
     'ipywidgets',
     'pymongo',
@@ -43,7 +41,8 @@ dependencies = [
     'uvicorn',
     'whoosh',
     'lancedb',
-    'deprecated'
+    'deprecated',
+    'pyyaml'
 ]
 dynamic = ["version"]
 
@@ -54,6 +53,18 @@ dev = [
     'pytest-cov',
     'mongomock'
 ]
+ollama = [
+    'ollama'
+]
+openai = [
+    'openai'
+]
+anthropic = [
+    'anthropic'
+]
+all = [
+    'talkpipe[openai,ollama,anthropic]'
+]
 
 [project.scripts]
 chatterlang_workbench = "talkpipe.app.chatterlang_workbench:main"

src/talkpipe/llm/config.py

@@ -1,13 +1,14 @@
 from typing import Dict, Type, TypeVar, List
-from .prompt_adapters import AbstractLLMPromptAdapter, OllamaPromptAdapter, OpenAIPromptAdapter
+from .prompt_adapters import AbstractLLMPromptAdapter, OllamaPromptAdapter, OpenAIPromptAdapter, AnthropicPromptAdapter
 from .embedding_adapters import AbstractEmbeddingAdapter, OllamaEmbedderAdapter
 
 T_PROMPTADAPTER = TypeVar("T_PROMPTADAPTER", bound=AbstractLLMPromptAdapter)
 T_EMBEDDINGADAPTER = TypeVar("T_EMBEDDINGADAPTER", bound=AbstractEmbeddingAdapter)
 
 _promptAdapter:Dict[str, Type[T_PROMPTADAPTER]] = {
     "ollama": OllamaPromptAdapter,
-    "openai": OpenAIPromptAdapter
+    "openai": OpenAIPromptAdapter,
+    "anthropic": AnthropicPromptAdapter
 }
 
 def registerPromptAdapter(name:str, promptAdapter:Type[T_PROMPTADAPTER]):

src/talkpipe/llm/embedding_adapters.py

@@ -1,7 +1,6 @@
 from typing import List
 
 import numpy as np
-import ollama
 
 class AbstractEmbeddingAdapter:
     """Abstract class for embedding text.
@@ -49,6 +48,13 @@ def __init__(self, model: str):
         super().__init__(model, "ollama")
 
     def execute(self, text: str) -> List[float]:
+        try:
+            import ollama
+        except ImportError:
+            raise ImportError(
+                "Ollama is not installed. Please install it with: pip install talkpipe[ollama]"
+            )
+
         response = ollama.embed(
             model=self.model_name,
             input=text

src/talkpipe/llm/prompt_adapters.py

@@ -1,7 +1,6 @@
+import json
 from pydantic import BaseModel
 import logging
-import ollama
-import openai
 
 from abc import ABC, abstractmethod
 
@@ -87,6 +86,13 @@ def execute(self, prompt: str) -> str:
 
         Handles its own multi-turn conversation state.
         """
+        try:
+            import ollama
+        except ImportError:
+            raise ImportError(
+                "Ollama is not installed. Please install it with: pip install talkpipe[ollama]"
+            )
+
         logger.debug(f"Adding user message to chat history: {prompt}")
         self._messages.append({"role": "user", "content": prompt})
 
@@ -117,6 +123,13 @@ def is_available(self) -> bool:
         Returns:
             bool: True if the model is available, False otherwise.
         """
+        try:
+            import ollama
+        except ImportError:
+            raise ImportError(
+                "Ollama is not installed. Please install it with: pip install talkpipe[ollama]"
+            )
+
         try:
             # Check if the model is available
             response = ollama.chat(self._model_name, messages=[self._system_message], options={"temperature": self._temperature})
@@ -126,12 +139,128 @@ def is_available(self) -> bool:
             return False
 
 
+class AnthropicPromptAdapter(AbstractLLMPromptAdapter):
+    """Prompt adapter for Anthropic Claude
+
+    """
+
+    def __init__(self, model: str, system_prompt: str = "You are a helpful assistant.", multi_turn: bool = True, temperature: float = None, output_format: BaseModel = None):
+        try:
+            import anthropic
+        except ImportError:
+            raise ImportError(
+                "Anthropic is not installed. Please install it with: pip install talkpipe[anthropic]"
+            )
+
+        if output_format:
+            self.pydantic_json_schema = json.dumps(output_format.model_json_schema())
+            system_prompt += f"\nThe output should be in the following JSON format:\n{self.pydantic_json_schema}"
+        else:
+            self.pydantic_json_schema = None
+
+        super().__init__(model, "anthropic", system_prompt, multi_turn, temperature, output_format)
+        self.client = anthropic.Anthropic()
+        self._max_tokens = 4096  # Default max tokens for response
+
+    def execute(self, prompt: str) -> str:
+        """Execute the chat model.
+
+        Handles its own multi-turn conversation state.
+        """
+        try:
+            import anthropic
+        except ImportError:
+            raise ImportError(
+                "Anthropic is not installed. Please install it with: pip install talkpipe[anthropic]"
+            )
+
+        logger.debug(f"Adding user message to chat history: {prompt}")
+        self._messages.append({"role": "user", "content": prompt})
+
+        logger.debug(f"Sending chat request to Anthropic model {self._model_name}")
+
+        # Build request parameters
+        request_params = {
+            "model": self._model_name,
+            "messages": self._messages,
+            "system": self._system_message["content"],
+            "max_tokens": self._max_tokens
+        }
+
+        if self._temperature_explicit:
+            request_params["temperature"] = self._temperature
+
+        response = self.client.messages.create(**request_params)
+
+        # Extract text content from response
+        response_text = ""
+        for block in response.content:
+            if hasattr(block, 'text'):
+                response_text += block.text
+
+        if self._multi_turn:
+            logger.debug("Multi-turn enabled, appending assistant response to chat history")
+            self._messages.append({"role": "assistant", "content": response_text})
+        else:
+            logger.debug("Single-turn mode, clearing message history")
+            self._messages = []
+
+        # Handle output format if specified
+        if self._output_format:
+            result = self._output_format.model_validate_json(response_text)
+        else:
+            result = response_text
+
+        logger.debug(f"Returning response: {result}")
+        return result
+
+    def is_available(self) -> bool:
+        """Check if the chat model is available.
+
+        This method should be implemented in each subclass to check if
+        the chat model is available.
+        Returns:
+            bool: True if the model is available, False otherwise.
+        """
+        try:
+            import anthropic
+        except ImportError:
+            raise ImportError(
+                "Anthropic is not installed. Please install it with: pip install talkpipe[anthropic]"
+            )
+
+        try:
+            # Check if the model is available by making a minimal request
+            request_params = {
+                "model": self._model_name,
+                "messages": [{"role": "user", "content": "test"}],
+                "system": self._system_message["content"],
+                "max_tokens": 1
+            }
+
+            if self._temperature_explicit:
+                request_params["temperature"] = self._temperature
+
+            response = self.client.messages.create(**request_params)
+            return True
+        except Exception as e:
+            logger.error(f"Model {self._model_name} is not available: {e}")
+            return False
+
+
 class OpenAIPromptAdapter(AbstractLLMPromptAdapter):
     """Prompt adapter for OpenAI
 
     """
 
     def __init__(self, model: str, system_prompt: str = "You are a helpful assistant.", multi_turn: bool = True, temperature: float = None, output_format: BaseModel = None):
+        try:
+            import openai
+        except ImportError:
+            raise ImportError(
+                "OpenAI is not installed. Please install it with: pip install talkpipe[openai]"
+            )
+
         super().__init__(model, "openai", system_prompt, multi_turn, temperature, output_format)
         self.client = openai.OpenAI()
 
@@ -140,11 +269,18 @@ def execute(self, prompt: str) -> str:
 
         Handles its own multi-turn conversation state.
         """
+        try:
+            import openai
+        except ImportError:
+            raise ImportError(
+                "OpenAI is not installed. Please install it with: pip install talkpipe[openai]"
+            )
+
         logger.debug(f"Adding user message to chat history: {prompt}")
         self._messages.append({"role": "user", "content": prompt})
 
         logger.debug(f"Sending chat request to OpenAI model {self._model_name}")
-        
+
         # Build request parameters, only including temperature if explicitly set
         request_params = {
             "model": self._model_name,

tests/conftest.py

@@ -58,6 +58,20 @@ def pytest_configure(config):
         config.is_openai_available = False
         logger.warning(f"OpenAI check failed: {e}. Skipping tests that require it.")
 
+    # Check if Anthropic is available (if needed in future)
+    try:
+        from talkpipe.llm.prompt_adapters import AnthropicPromptAdapter
+        anthropic_adapter = AnthropicPromptAdapter("claude-3-5-haiku-latest", temperature=0.0)
+        if anthropic_adapter.is_available():
+            config.is_anthropic_available = True
+            logger.warning("Anthropic is available.")
+        else:
+            config.is_anthropic_available = False
+            logger.warning("Anthropic is not available. Skipping tests that require it.")
+    except Exception as e:
+        config.is_anthropic_available = False
+        logger.warning(f"Anthropic check failed: {e}. Skipping tests that require it.")
+
 @pytest.fixture
 def requires_mongodb(request):
     """
@@ -87,6 +101,20 @@ def test_something(requires_ollama):
         pytest.skip("Test requires Ollama with llama3.2, but this model or the server is not available")
     return True
 
+@pytest.fixture
+def requires_anthropic(request):
+    """
+    Fixture that skips tests if Anthropic is not available.
+    
+    Usage:
+        def test_something(requires_anthropic):
+            # This test will be skipped if Anthropic is not available
+            ...
+    """
+    if not request.config.is_anthropic_available:
+        pytest.skip("Test requires Anthropic, but Anthropic is not available")
+    return True
+
 @pytest.fixture
 def requires_openai(request):
     """