chatterer 0.1.0__tar.gz

chatterer-0.1.0/PKG-INFO

@@ -0,0 +1,211 @@
+Metadata-Version: 2.2
+Name: chatterer
+Version: 0.1.0
+Summary: The highest-level interface for various LLM APIs.
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: openai>=1.63.2
+Provides-Extra: all
+Requires-Dist: anthropic>=0.46.0; extra == "all"
+Requires-Dist: instructor>=1.7.2; extra == "all"
+Requires-Dist: langchain-community>=0.3.18; extra == "all"
+Requires-Dist: ollama>=0.4.7; extra == "all"
+
+# chatterer
+
+`chatterer` is a Python library that provides a unified interface for interacting with various Language Model (LLM) backends. It abstracts over different providers such as OpenAI, Anthropic, DeepSeek, Ollama, and Langchain, allowing you to generate completions, stream responses, and even validate outputs using Pydantic models.
+
+---
+
+## Features
+
+- **Unified LLM Interface**  
+  Define a common interface (`LLM`) for generating completions and streaming responses regardless of the underlying provider.
+
+- **Multiple Backend Support**  
+  Built-in support for:
+  - **InstructorLLM**: Integrates with OpenAI, Anthropic, and DeepSeek.
+  - **OllamaLLM**: Supports the Ollama model with optional streaming and formatting.
+  - **LangchainLLM**: Leverages Langchain’s chat models with conversion utilities.
+
+- **Pydantic Integration**  
+  Easily validate and structure LLM responses by leveraging Pydantic models with methods like `generate_pydantic` and `generate_pydantic_stream`.
+
+---
+
+## Installation
+
+Assuming `chatterer` is published on PyPI, install it via pip:
+
+```bash
+pip install chatterer
+```
+
+Alternatively, clone the repository and install manually:
+
+```bash
+git clone https://github.com/yourusername/chatterer.git
+cd chatterer
+pip install -r requirements.txt
+```
+
+---
+
+## Usage
+
+### Importing the Library
+
+You can import the core components directly from `chatterer`:
+
+```python
+from chatterer import LLM, InstructorLLM, OllamaLLM, LangchainLLM
+```
+
+---
+
+### Example 1: Using InstructorLLM with OpenAI
+
+```python
+from chatterer import InstructorLLM
+from openai.types.chat import ChatCompletionMessageParam
+
+# Create an instance for OpenAI using the InstructorLLM wrapper
+llm = InstructorLLM.openai(call_kwargs={"model": "o3-mini"})
+
+# Define a conversation message list
+messages: list[ChatCompletionMessageParam] = [
+    {"role": "user", "content": "Hello, how can I help you?"}
+]
+
+# Generate a completion
+response = llm.generate(messages)
+print("Response:", response)
+
+# Stream the response incrementally
+print("Streaming response:")
+for chunk in llm.generate_stream(messages):
+    print(chunk, end="")
+```
+
+---
+
+### Example 2: Using OllamaLLM
+
+```python
+from chatterer import OllamaLLM
+from openai.types.chat import ChatCompletionMessageParam
+
+# Initialize an OllamaLLM instance with streaming enabled
+llm = OllamaLLM(model="ollama-model", stream=True)
+
+messages: list[ChatCompletionMessageParam] = [
+    {"role": "user", "content": "Tell me a joke."}
+]
+
+# Generate and print the full response
+print("Response:", llm.generate(messages))
+
+# Stream the response chunk by chunk
+print("Streaming response:")
+for chunk in llm.generate_stream(messages):
+    print(chunk, end="")
+```
+
+---
+
+### Example 3: Using LangchainLLM
+
+```python
+from chatterer import LangchainLLM
+from openai.types.chat import ChatCompletionMessageParam
+# Ensure you have a Langchain chat model instance; for example:
+from langchain_core.language_models.chat_models import BaseChatModel
+
+client: BaseChatModel = ...  # Initialize your Langchain chat model here
+llm = LangchainLLM(client=client)
+
+messages: list[ChatCompletionMessageParam] = [
+    {"role": "user", "content": "What is the weather like today?"}
+]
+
+# Generate a complete response
+response = llm.generate(messages)
+print("Response:", response)
+
+# Stream the response
+print("Streaming response:")
+for chunk in llm.generate_stream(messages):
+    print(chunk, end="")
+```
+
+---
+
+### Example 4: Using Pydantic for Structured Outputs
+
+```python
+from pydantic import BaseModel
+from chatterer import InstructorLLM
+from openai.types.chat import ChatCompletionMessageParam
+
+# Define a response model
+class MyResponse(BaseModel):
+    response: str
+
+# Initialize the InstructorLLM instance
+llm = InstructorLLM.openai()
+
+messages: list[ChatCompletionMessageParam] = [
+    {"role": "user", "content": "Summarize this text."}
+]
+
+# Generate a structured response using a Pydantic model
+structured_response = llm.generate_pydantic(MyResponse, messages)
+print("Structured Response:", structured_response.response)
+```
+
+---
+
+## API Overview
+
+### `LLM` (Abstract Base Class)
+
+- **Methods:**
+  - `generate(messages: Sequence[ChatCompletionMessageParam]) -> str`  
+    Generate a complete text response from a list of messages.
+  
+  - `generate_stream(messages: Sequence[ChatCompletionMessageParam]) -> Iterator[str]`  
+    Stream the response incrementally.
+  
+  - `generate_pydantic(response_model: Type[P], messages: Sequence[ChatCompletionMessageParam]) -> P`  
+    Generate and validate the response using a Pydantic model.
+  
+  - `generate_pydantic_stream(response_model: Type[P], messages: Sequence[ChatCompletionMessageParam]) -> Iterator[P]`  
+    (Optional) Stream validated responses as Pydantic models.
+
+### `InstructorLLM`
+
+- Factory methods to create instances with various backends:
+  - `openai()`
+  - `anthropic()`
+  - `deepseek()`
+
+### `OllamaLLM`
+
+- Supports additional options such as:
+  - `model`, `stream`, `format`, `tools`, `options`, `keep_alive`
+
+### `LangchainLLM`
+
+- Integrates with Langchain's BaseChatModel and converts messages to a compatible format.
+
+---
+
+## Contributing
+
+Contributions are highly encouraged! If you find a bug or have a feature request, please open an issue or submit a pull request on the repository. When contributing, please ensure your code adheres to the existing style and passes all tests.
+
+---
+
+## License
+
+This project is licensed under the MIT License.

chatterer-0.1.0/README.md

@@ -0,0 +1,198 @@
+# chatterer
+
+`chatterer` is a Python library that provides a unified interface for interacting with various Language Model (LLM) backends. It abstracts over different providers such as OpenAI, Anthropic, DeepSeek, Ollama, and Langchain, allowing you to generate completions, stream responses, and even validate outputs using Pydantic models.
+
+---
+
+## Features
+
+- **Unified LLM Interface**  
+  Define a common interface (`LLM`) for generating completions and streaming responses regardless of the underlying provider.
+
+- **Multiple Backend Support**  
+  Built-in support for:
+  - **InstructorLLM**: Integrates with OpenAI, Anthropic, and DeepSeek.
+  - **OllamaLLM**: Supports the Ollama model with optional streaming and formatting.
+  - **LangchainLLM**: Leverages Langchain’s chat models with conversion utilities.
+
+- **Pydantic Integration**  
+  Easily validate and structure LLM responses by leveraging Pydantic models with methods like `generate_pydantic` and `generate_pydantic_stream`.
+
+---
+
+## Installation
+
+Assuming `chatterer` is published on PyPI, install it via pip:
+
+```bash
+pip install chatterer
+```
+
+Alternatively, clone the repository and install manually:
+
+```bash
+git clone https://github.com/yourusername/chatterer.git
+cd chatterer
+pip install -r requirements.txt
+```
+
+---
+
+## Usage
+
+### Importing the Library
+
+You can import the core components directly from `chatterer`:
+
+```python
+from chatterer import LLM, InstructorLLM, OllamaLLM, LangchainLLM
+```
+
+---
+
+### Example 1: Using InstructorLLM with OpenAI
+
+```python
+from chatterer import InstructorLLM
+from openai.types.chat import ChatCompletionMessageParam
+
+# Create an instance for OpenAI using the InstructorLLM wrapper
+llm = InstructorLLM.openai(call_kwargs={"model": "o3-mini"})
+
+# Define a conversation message list
+messages: list[ChatCompletionMessageParam] = [
+    {"role": "user", "content": "Hello, how can I help you?"}
+]
+
+# Generate a completion
+response = llm.generate(messages)
+print("Response:", response)
+
+# Stream the response incrementally
+print("Streaming response:")
+for chunk in llm.generate_stream(messages):
+    print(chunk, end="")
+```
+
+---
+
+### Example 2: Using OllamaLLM
+
+```python
+from chatterer import OllamaLLM
+from openai.types.chat import ChatCompletionMessageParam
+
+# Initialize an OllamaLLM instance with streaming enabled
+llm = OllamaLLM(model="ollama-model", stream=True)
+
+messages: list[ChatCompletionMessageParam] = [
+    {"role": "user", "content": "Tell me a joke."}
+]
+
+# Generate and print the full response
+print("Response:", llm.generate(messages))
+
+# Stream the response chunk by chunk
+print("Streaming response:")
+for chunk in llm.generate_stream(messages):
+    print(chunk, end="")
+```
+
+---
+
+### Example 3: Using LangchainLLM
+
+```python
+from chatterer import LangchainLLM
+from openai.types.chat import ChatCompletionMessageParam
+# Ensure you have a Langchain chat model instance; for example:
+from langchain_core.language_models.chat_models import BaseChatModel
+
+client: BaseChatModel = ...  # Initialize your Langchain chat model here
+llm = LangchainLLM(client=client)
+
+messages: list[ChatCompletionMessageParam] = [
+    {"role": "user", "content": "What is the weather like today?"}
+]
+
+# Generate a complete response
+response = llm.generate(messages)
+print("Response:", response)
+
+# Stream the response
+print("Streaming response:")
+for chunk in llm.generate_stream(messages):
+    print(chunk, end="")
+```
+
+---
+
+### Example 4: Using Pydantic for Structured Outputs
+
+```python
+from pydantic import BaseModel
+from chatterer import InstructorLLM
+from openai.types.chat import ChatCompletionMessageParam
+
+# Define a response model
+class MyResponse(BaseModel):
+    response: str
+
+# Initialize the InstructorLLM instance
+llm = InstructorLLM.openai()
+
+messages: list[ChatCompletionMessageParam] = [
+    {"role": "user", "content": "Summarize this text."}
+]
+
+# Generate a structured response using a Pydantic model
+structured_response = llm.generate_pydantic(MyResponse, messages)
+print("Structured Response:", structured_response.response)
+```
+
+---
+
+## API Overview
+
+### `LLM` (Abstract Base Class)
+
+- **Methods:**
+  - `generate(messages: Sequence[ChatCompletionMessageParam]) -> str`  
+    Generate a complete text response from a list of messages.
+  
+  - `generate_stream(messages: Sequence[ChatCompletionMessageParam]) -> Iterator[str]`  
+    Stream the response incrementally.
+  
+  - `generate_pydantic(response_model: Type[P], messages: Sequence[ChatCompletionMessageParam]) -> P`  
+    Generate and validate the response using a Pydantic model.
+  
+  - `generate_pydantic_stream(response_model: Type[P], messages: Sequence[ChatCompletionMessageParam]) -> Iterator[P]`  
+    (Optional) Stream validated responses as Pydantic models.
+
+### `InstructorLLM`
+
+- Factory methods to create instances with various backends:
+  - `openai()`
+  - `anthropic()`
+  - `deepseek()`
+
+### `OllamaLLM`
+
+- Supports additional options such as:
+  - `model`, `stream`, `format`, `tools`, `options`, `keep_alive`
+
+### `LangchainLLM`
+
+- Integrates with Langchain's BaseChatModel and converts messages to a compatible format.
+
+---
+
+## Contributing
+
+Contributions are highly encouraged! If you find a bug or have a feature request, please open an issue or submit a pull request on the repository. When contributing, please ensure your code adheres to the existing style and passes all tests.
+
+---
+
+## License
+
+This project is licensed under the MIT License.

chatterer-0.1.0/chatterer/__init__.py

@@ -0,0 +1,13 @@
+from .llms import (
+    LLM,
+    InstructorLLM,
+    LangchainLLM,
+    OllamaLLM,
+)
+
+__all__ = [
+    "InstructorLLM",
+    "LangchainLLM",
+    "LLM",
+    "OllamaLLM",
+]

chatterer-0.1.0/chatterer/llms.py

@@ -0,0 +1,291 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from os import environ
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Iterator,
+    Literal,
+    Mapping,
+    Optional,
+    Self,
+    Sequence,
+    Type,
+    TypeVar,
+)
+
+from openai import OpenAI
+from openai.types.chat import ChatCompletionMessageParam
+from pydantic import BaseModel, create_model
+from pydantic.json_schema import JsonSchemaValue
+
+if TYPE_CHECKING:
+    from instructor import Instructor
+    from langchain_core.language_models.chat_models import BaseChatModel
+    from ollama import Options, Tool
+
+P = TypeVar("P", bound=BaseModel)
+
+
+@dataclass
+class LLM(ABC):
+    call_kwargs: dict[str, Any]
+
+    @abstractmethod
+    def generate(
+        self, messages: Sequence[ChatCompletionMessageParam]
+    ) -> str: ...
+
+    @abstractmethod
+    def generate_stream(
+        self, messages: Sequence[ChatCompletionMessageParam]
+    ) -> Iterator[str]: ...
+
+    @abstractmethod
+    def generate_pydantic(
+        self,
+        response_model: Type[P],
+        messages: Sequence[ChatCompletionMessageParam],
+    ) -> P: ...
+
+    def generate_pydantic_stream(
+        self,
+        response_model: Type[P],
+        messages: Sequence[ChatCompletionMessageParam],
+    ) -> Iterator[P]:
+        raise NotImplementedError
+
+
+@dataclass
+class InstructorLLM(LLM):
+    inst: "Instructor"
+
+    @property
+    def dependency(self) -> list[str]:
+        return ["instructor"]
+
+    @classmethod
+    def openai(
+        cls, call_kwargs: dict[str, Any] = {"model": "o3-mini"}
+    ) -> Self:
+        from instructor import Mode, from_openai
+
+        return cls(
+            inst=from_openai(OpenAI(), Mode.TOOLS_STRICT),
+            call_kwargs=call_kwargs,
+        )
+
+    @classmethod
+    def anthropic(
+        cls,
+        call_kwargs: dict[str, Any] = {
+            "temperature": 0.7,
+            "max_tokens": 8192,
+            "model": "claude-3-5-sonnet-20241022",
+        },
+    ) -> Self:
+
+        from anthropic import Anthropic
+        from instructor import Mode, from_anthropic
+
+        return cls(
+            inst=from_anthropic(
+                client=Anthropic(), mode=Mode.ANTHROPIC_TOOLS
+            ),
+            call_kwargs=call_kwargs,
+        )
+
+    @classmethod
+    def deepseek(
+        cls, call_kwargs: dict[str, Any] = {"model": "deepseek-chat"}
+    ) -> Self:
+
+        from instructor import Mode, from_openai
+
+        return cls(
+            inst=from_openai(
+                OpenAI(
+                    base_url="https://api.deepseek.com/v1",
+                    api_key=environ["DEEPSEEK_API_KEY"],
+                ),
+                Mode.TOOLS_STRICT,
+            ),
+            call_kwargs=call_kwargs,
+        )
+
+    def generate(
+        self, messages: Sequence[ChatCompletionMessageParam]
+    ) -> str:
+        res = self.inst.chat.completions.create(
+            response_model=create_model(
+                "Response",
+                response=(str, ...),
+            ),
+            messages=list(messages),
+            **self.call_kwargs,
+        )
+        return str(getattr(res, "response", "") or "")
+
+    def generate_stream(
+        self, messages: Sequence[ChatCompletionMessageParam]
+    ) -> Iterator[str]:
+        last_content: str = ""
+        for res in self.inst.chat.completions.create_partial(
+            response_model=create_model(
+                "Response",
+                response=(str, ...),
+            ),
+            messages=list(messages),
+            **self.call_kwargs,
+        ):
+            content = str(getattr(res, "response", "") or "")
+            delta: str = content.removeprefix(last_content)
+            if not delta:
+                continue
+            last_content = content
+            yield delta
+
+    def generate_pydantic(
+        self,
+        response_model: Type[P],
+        messages: Sequence[ChatCompletionMessageParam],
+    ) -> P:
+        return self.inst.chat.completions.create(
+            response_model=response_model,
+            messages=list(messages),
+            **self.call_kwargs,
+        )
+
+    def generate_pydantic_stream(
+        self,
+        response_model: Type[P],
+        messages: Sequence[ChatCompletionMessageParam],
+    ) -> Iterator[P]:
+        for res in self.inst.chat.completions.create_partial(
+            response_model=response_model,
+            messages=list(messages),
+            **self.call_kwargs,
+        ):
+            yield res
+
+
+@dataclass
+class OllamaLLM(LLM):
+    model: str
+    tools: Optional[Sequence[Mapping[str, Any] | "Tool" | Callable]] = None
+    stream: bool = False
+    format: Optional[Literal["", "json"] | JsonSchemaValue] = None
+    options: Optional[Mapping[str, Any] | "Options"] = None
+    keep_alive: Optional[float | str] = None
+
+    def generate(
+        self, messages: Sequence[ChatCompletionMessageParam]
+    ) -> str:
+        return "".join(self.generate_stream(messages))
+
+    def generate_stream(
+        self, messages: Sequence[ChatCompletionMessageParam]
+    ) -> Iterator[str]:
+        from ollama import chat
+
+        model = str(self.call_kwargs.get("model", self.model))
+        format = self.call_kwargs.get("format", self.format)
+        options = self.call_kwargs.get("options", self.options)
+        keep_alive = self.call_kwargs.get("keep_alive", self.keep_alive)
+        tools = self.call_kwargs.get("tools", self.tools)
+        return (
+            res.message.content or ""
+            for res in chat(
+                model=model,
+                messages=messages,
+                tools=tools,
+                stream=True,
+                format=format,
+                options=options,
+                keep_alive=keep_alive,
+            )
+        )
+
+    def generate_pydantic(
+        self,
+        response_model: Type[P],
+        messages: Sequence[ChatCompletionMessageParam],
+    ) -> P:
+        from ollama import chat
+
+        model = str(self.call_kwargs.get("model", self.model))
+        format = response_model.model_json_schema()
+        options = self.call_kwargs.get("options", self.options)
+        keep_alive = self.call_kwargs.get("keep_alive", self.keep_alive)
+        return response_model.model_validate_json(
+            chat(
+                model=model,
+                messages=messages,
+                tools=None,
+                stream=False,
+                format=format,
+                options=options,
+                keep_alive=keep_alive,
+            ).message.content
+            or ""
+        )
+
+
+@dataclass
+class LangchainLLM(LLM):
+    client: "BaseChatModel"
+
+    def generate(
+        self, messages: Sequence[ChatCompletionMessageParam]
+    ) -> str:
+        from langchain_community.adapters.openai import (
+            convert_openai_messages,
+        )
+
+        content = self.client.invoke(
+            convert_openai_messages([dict(msg) for msg in messages])
+        ).content
+        if isinstance(content, str):
+            return content
+        else:
+            return "".join(part for part in content if isinstance(part, str))
+
+    def generate_stream(
+        self, messages: Sequence[ChatCompletionMessageParam]
+    ) -> Iterator[str]:
+        from langchain_community.adapters.openai import (
+            convert_openai_messages,
+        )
+
+        for chunk in self.client.stream(
+            convert_openai_messages([dict(msg) for msg in messages])
+        ):
+            content = chunk.content
+            if isinstance(content, str):
+                yield content
+            elif isinstance(content, list):
+                for part in content:
+                    if isinstance(part, str):
+                        yield part
+                    else:
+                        continue
+            else:
+                continue
+
+    def generate_pydantic(
+        self,
+        response_model: Type[P],
+        messages: Sequence[ChatCompletionMessageParam],
+    ) -> P:
+        from langchain_community.adapters.openai import (
+            convert_openai_messages,
+        )
+
+        result = self.client.with_structured_output(response_model).invoke(
+            convert_openai_messages([dict(msg) for msg in messages])
+        )
+        if isinstance(result, response_model):
+            return result
+        else:
+            return response_model.model_validate(result)

chatterer-0.1.0/chatterer.egg-info/PKG-INFO

@@ -0,0 +1,211 @@
+Metadata-Version: 2.2
+Name: chatterer
+Version: 0.1.0
+Summary: The highest-level interface for various LLM APIs.
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: openai>=1.63.2
+Provides-Extra: all
+Requires-Dist: anthropic>=0.46.0; extra == "all"
+Requires-Dist: instructor>=1.7.2; extra == "all"
+Requires-Dist: langchain-community>=0.3.18; extra == "all"
+Requires-Dist: ollama>=0.4.7; extra == "all"
+
+# chatterer
+
+`chatterer` is a Python library that provides a unified interface for interacting with various Language Model (LLM) backends. It abstracts over different providers such as OpenAI, Anthropic, DeepSeek, Ollama, and Langchain, allowing you to generate completions, stream responses, and even validate outputs using Pydantic models.
+
+---
+
+## Features
+
+- **Unified LLM Interface**  
+  Define a common interface (`LLM`) for generating completions and streaming responses regardless of the underlying provider.
+
+- **Multiple Backend Support**  
+  Built-in support for:
+  - **InstructorLLM**: Integrates with OpenAI, Anthropic, and DeepSeek.
+  - **OllamaLLM**: Supports the Ollama model with optional streaming and formatting.
+  - **LangchainLLM**: Leverages Langchain’s chat models with conversion utilities.
+
+- **Pydantic Integration**  
+  Easily validate and structure LLM responses by leveraging Pydantic models with methods like `generate_pydantic` and `generate_pydantic_stream`.
+
+---
+
+## Installation
+
+Assuming `chatterer` is published on PyPI, install it via pip:
+
+```bash
+pip install chatterer
+```
+
+Alternatively, clone the repository and install manually:
+
+```bash
+git clone https://github.com/yourusername/chatterer.git
+cd chatterer
+pip install -r requirements.txt
+```
+
+---
+
+## Usage
+
+### Importing the Library
+
+You can import the core components directly from `chatterer`:
+
+```python
+from chatterer import LLM, InstructorLLM, OllamaLLM, LangchainLLM
+```
+
+---
+
+### Example 1: Using InstructorLLM with OpenAI
+
+```python
+from chatterer import InstructorLLM
+from openai.types.chat import ChatCompletionMessageParam
+
+# Create an instance for OpenAI using the InstructorLLM wrapper
+llm = InstructorLLM.openai(call_kwargs={"model": "o3-mini"})
+
+# Define a conversation message list
+messages: list[ChatCompletionMessageParam] = [
+    {"role": "user", "content": "Hello, how can I help you?"}
+]
+
+# Generate a completion
+response = llm.generate(messages)
+print("Response:", response)
+
+# Stream the response incrementally
+print("Streaming response:")
+for chunk in llm.generate_stream(messages):
+    print(chunk, end="")
+```
+
+---
+
+### Example 2: Using OllamaLLM
+
+```python
+from chatterer import OllamaLLM
+from openai.types.chat import ChatCompletionMessageParam
+
+# Initialize an OllamaLLM instance with streaming enabled
+llm = OllamaLLM(model="ollama-model", stream=True)
+
+messages: list[ChatCompletionMessageParam] = [
+    {"role": "user", "content": "Tell me a joke."}
+]
+
+# Generate and print the full response
+print("Response:", llm.generate(messages))
+
+# Stream the response chunk by chunk
+print("Streaming response:")
+for chunk in llm.generate_stream(messages):
+    print(chunk, end="")
+```
+
+---
+
+### Example 3: Using LangchainLLM
+
+```python
+from chatterer import LangchainLLM
+from openai.types.chat import ChatCompletionMessageParam
+# Ensure you have a Langchain chat model instance; for example:
+from langchain_core.language_models.chat_models import BaseChatModel
+
+client: BaseChatModel = ...  # Initialize your Langchain chat model here
+llm = LangchainLLM(client=client)
+
+messages: list[ChatCompletionMessageParam] = [
+    {"role": "user", "content": "What is the weather like today?"}
+]
+
+# Generate a complete response
+response = llm.generate(messages)
+print("Response:", response)
+
+# Stream the response
+print("Streaming response:")
+for chunk in llm.generate_stream(messages):
+    print(chunk, end="")
+```
+
+---
+
+### Example 4: Using Pydantic for Structured Outputs
+
+```python
+from pydantic import BaseModel
+from chatterer import InstructorLLM
+from openai.types.chat import ChatCompletionMessageParam
+
+# Define a response model
+class MyResponse(BaseModel):
+    response: str
+
+# Initialize the InstructorLLM instance
+llm = InstructorLLM.openai()
+
+messages: list[ChatCompletionMessageParam] = [
+    {"role": "user", "content": "Summarize this text."}
+]
+
+# Generate a structured response using a Pydantic model
+structured_response = llm.generate_pydantic(MyResponse, messages)
+print("Structured Response:", structured_response.response)
+```
+
+---
+
+## API Overview
+
+### `LLM` (Abstract Base Class)
+
+- **Methods:**
+  - `generate(messages: Sequence[ChatCompletionMessageParam]) -> str`  
+    Generate a complete text response from a list of messages.
+  
+  - `generate_stream(messages: Sequence[ChatCompletionMessageParam]) -> Iterator[str]`  
+    Stream the response incrementally.
+  
+  - `generate_pydantic(response_model: Type[P], messages: Sequence[ChatCompletionMessageParam]) -> P`  
+    Generate and validate the response using a Pydantic model.
+  
+  - `generate_pydantic_stream(response_model: Type[P], messages: Sequence[ChatCompletionMessageParam]) -> Iterator[P]`  
+    (Optional) Stream validated responses as Pydantic models.
+
+### `InstructorLLM`
+
+- Factory methods to create instances with various backends:
+  - `openai()`
+  - `anthropic()`
+  - `deepseek()`
+
+### `OllamaLLM`
+
+- Supports additional options such as:
+  - `model`, `stream`, `format`, `tools`, `options`, `keep_alive`
+
+### `LangchainLLM`
+
+- Integrates with Langchain's BaseChatModel and converts messages to a compatible format.
+
+---
+
+## Contributing
+
+Contributions are highly encouraged! If you find a bug or have a feature request, please open an issue or submit a pull request on the repository. When contributing, please ensure your code adheres to the existing style and passes all tests.
+
+---
+
+## License
+
+This project is licensed under the MIT License.

chatterer-0.1.0/chatterer.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+chatterer/__init__.py
+chatterer/llms.py
+chatterer.egg-info/PKG-INFO
+chatterer.egg-info/SOURCES.txt
+chatterer.egg-info/dependency_links.txt
+chatterer.egg-info/requires.txt
+chatterer.egg-info/top_level.txt

chatterer-0.1.0/chatterer.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

chatterer-0.1.0/chatterer.egg-info/requires.txt

@@ -0,0 +1,7 @@
+openai>=1.63.2
+
+[all]
+anthropic>=0.46.0
+instructor>=1.7.2
+langchain-community>=0.3.18
+ollama>=0.4.7

chatterer-0.1.0/chatterer.egg-info/top_level.txt

@@ -0,0 +1 @@
+chatterer

chatterer-0.1.0/pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name = "chatterer"
+version = "0.1.0"
+description = "The highest-level interface for various LLM APIs."
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = ["openai>=1.63.2"]
+
+[project.optional-dependencies]
+all = [
+    "anthropic>=0.46.0",
+    "instructor>=1.7.2",
+    "langchain-community>=0.3.18",
+    "ollama>=0.4.7",
+]

chatterer-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+