generic-llm-memorizer 0.1.0__tar.gz

generic_llm_memorizer-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 jlesbegu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

generic_llm_memorizer-0.1.0/PKG-INFO

@@ -0,0 +1,250 @@
+Metadata-Version: 2.4
+Name: generic-llm-memorizer
+Version: 0.1.0
+Summary: A library for managing LLM conversations and context
+Author-email: Your Name <your.email@example.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/yourusername/generic-llm-memorizer
+Project-URL: Documentation, https://github.com/yourusername/generic-llm-memorizer#readme
+Project-URL: Repository, https://github.com/yourusername/generic-llm-memorizer
+Keywords: llm,conversation,chat,ai,prompt,context-management
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic-ai>=1.76.0
+Requires-Dist: pytest>=9.0.2
+Requires-Dist: pytest-asyncio>=1.3.0
+Dynamic: license-file
+
+# Generic LLM Memorizer
+
+A Python library for managing LLM conversations and context with automatic fact extraction and structured data handling.
+
+## Installation
+
+```bash
+pip install generic-llm-memorizer
+```
+
+## Usage
+
+### Basic Conversation Management
+
+```python
+from generic_llm_memorizer import Conversation
+
+# Create a new conversation
+conv = Conversation(system_prompt="You are a helpful assistant.")
+
+# Add messages
+conv.add_user_message("Hello, how are you?")
+conv.add_assistant_message("I'm doing well, thank you! How can I help you today?")
+
+# Get conversation history
+messages = conv.get_messages()
+
+# Format for LLM API (expects list of dicts with role and content)
+from generic_llm_memorizer import format_conversation_for_prompt
+formatted = format_conversation_for_prompt(conv)
+# Output: [{"role": "system", "content": "You are a helpful assistant."}, ...]
+```
+
+```python
+from generic_llm_memorizer import Conversation
+
+# Create a new conversation
+conv = Conversation(system_prompt="You are a helpful assistant.")
+
+# Add messages
+conv.add_user_message("Hello, how are you?")
+conv.add_assistant_message("I'm doing well, thank you! How can I help you today?")
+
+# Get conversation history
+messages = conv.get_messages()
+
+# Format for LLM API (expects list of dicts with role and content)
+from generic_llm_memorizer import format_conversation_for_prompt
+formatted = format_conversation_for_prompt(conv)
+# Output: [{"role": "system", "content": "You are a helpful assistant."}, ...]
+```
+
+### Persisting Conversations
+
+```python
+from generic_llm_memorizer import Conversation
+
+# Save conversation to JSON
+conv_json = conv.to_json()
+with open("conversation.json", "w") as f:
+    f.write(conv_json)
+
+# Load conversation from JSON
+with open("conversation.json", "r") as f:
+    conv_json = f.read()
+loaded_conv = Conversation.from_json(conv_json)
+```
+
+```python
+from generic_llm_memorizer import Conversation
+
+# Save conversation to JSON
+conv_json = conv.to_json()
+with open("conversation.json", "w") as f:
+    f.write(conv_json)
+
+# Load conversation from JSON
+with open("conversation.json", "r") as f:
+    conv_json = f.read()
+loaded_conv = Conversation.from_json(conv_json)
+```
+
+### Utility Functions
+
+## Extending with Custom Models
+
+You can create your own Pydantic models for domain-specific extractions:
+
+```python
+from pydantic import BaseModel
+from typing import List
+from enum import Enum
+
+class Priority(str, Enum):
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+
+class Task(BaseModel):
+    title: str
+    description: str
+    priority: Priority
+    assignee: str
+
+class TaskList(BaseModel):
+    tasks: List[Task]
+
+# Use with the generic llm_call function
+tasks = llm_call("Extract tasks from this conversation", TaskList)
+```
+
+### Advanced Usage with Structured Data Extraction
+
+The library now supports a generic `llm_call` function that works with Pydantic models for structured data extraction:
+
+```python
+from typing import Type, TypeVar
+from pydantic import BaseModel
+from generic_llm_memorizer.conversation import Conversation
+from generic_llm_memorizer.memory import Summary, Memory, Fact
+
+# Define a generic type variable bounded by BaseModel
+T = TypeVar("T", bound=BaseModel)
+
+def llm_call(prompt: str, model_class: Type[T]) -> T:
+    """
+    Generic LLM call function that returns structured data.
+    
+    Args:
+        prompt: The prompt to send to the LLM
+        model_class: The Pydantic model class to parse the response into
+        
+    Returns:
+        An instance of the specified model_class
+    """
+    # In a real implementation, this would call an actual LLM API
+    # and parse the response into the specified Pydantic model
+    
+    # Mock implementation for demonstration
+    if model_class == Summary:
+        return Summary(content="Mock summary of the conversation")
+    elif model_class == Memory:
+        return Memory(facts=[
+            Fact(
+                content="Example fact extracted from conversation",
+                kind="example",
+                timestamp="2023-01-01T10:00:00Z",
+                validity="forever"
+            )
+        ])
+    
+    # Return a default instance of the model
+    return model_class()
+
+# Usage with LLMMemorizer
+from generic_llm_memorizer.llm_memorizer import LLMMemorizer
+
+conversation = Conversation(system_prompt="You are a helpful assistant")
+conversation.add_user_message("Hello, my name is John Doe and I'm a software engineer")
+
+memorizer = LLMMemorizer(
+    user_id="user_123",
+    session_id="session_456",
+    llm_call=llm_call,
+    conversation=conversation
+)
+
+# Extract structured facts
+memory = memorizer.extract_facts()
+print(f"Extracted {len(memory.facts)} facts")
+
+# Generate structured summary
+summary = memorizer.summarize()
+print(f"Summary: {summary.content}")
+
+## API Reference
+
+```python
+from generic_llm_memorizer import extract_last_user_message, extract_last_assistant_message
+
+# Extract last user message
+last_user = extract_last_user_message(conv)
+
+# Extract last assistant message
+last_assistant = extract_last_assistant_message(conv)
+```
+
+## API Reference
+
+### Conversation Class
+
+Manages a conversation with an LLM.
+
+#### Methods
+
+- `add_message(role, content, metadata=None)`: Add a message to the conversation
+- `add_user_message(content, metadata=None)`: Add a user message
+- `add_assistant_message(content, metadata=None)`: Add an assistant message
+- `get_messages()`: Get all messages
+- `get_recent_messages(count)`: Get the most recent messages
+- `clear()`: Clear all messages
+- `to_dict()`: Convert to dictionary format
+- `to_json(indent=2)`: Convert to JSON string
+- `from_dict(data)`: Create from dictionary data
+- `from_json(json_str)`: Create from JSON string
+
+### Message Dataclass
+
+Represents a single message in a conversation.
+
+#### Attributes
+
+- `role`: Role of the message sender ("user", "assistant", "system", etc.)
+- `content`: Message content
+- `timestamp`: ISO format timestamp (automatically set)
+- `metadata`: Additional metadata dictionary
+
+### Utility Functions
+
+- `format_conversation_for_prompt(conversation)`: Format conversation for LLM API
+- `extract_last_user_message(conversation)`: Get last user message content
+- `extract_last_assistant_message(conversation)`: Get last assistant message content
+
+## License
+
+MIT

generic_llm_memorizer-0.1.0/README.md

@@ -0,0 +1,226 @@
+# Generic LLM Memorizer
+
+A Python library for managing LLM conversations and context with automatic fact extraction and structured data handling.
+
+## Installation
+
+```bash
+pip install generic-llm-memorizer
+```
+
+## Usage
+
+### Basic Conversation Management
+
+```python
+from generic_llm_memorizer import Conversation
+
+# Create a new conversation
+conv = Conversation(system_prompt="You are a helpful assistant.")
+
+# Add messages
+conv.add_user_message("Hello, how are you?")
+conv.add_assistant_message("I'm doing well, thank you! How can I help you today?")
+
+# Get conversation history
+messages = conv.get_messages()
+
+# Format for LLM API (expects list of dicts with role and content)
+from generic_llm_memorizer import format_conversation_for_prompt
+formatted = format_conversation_for_prompt(conv)
+# Output: [{"role": "system", "content": "You are a helpful assistant."}, ...]
+```
+
+```python
+from generic_llm_memorizer import Conversation
+
+# Create a new conversation
+conv = Conversation(system_prompt="You are a helpful assistant.")
+
+# Add messages
+conv.add_user_message("Hello, how are you?")
+conv.add_assistant_message("I'm doing well, thank you! How can I help you today?")
+
+# Get conversation history
+messages = conv.get_messages()
+
+# Format for LLM API (expects list of dicts with role and content)
+from generic_llm_memorizer import format_conversation_for_prompt
+formatted = format_conversation_for_prompt(conv)
+# Output: [{"role": "system", "content": "You are a helpful assistant."}, ...]
+```
+
+### Persisting Conversations
+
+```python
+from generic_llm_memorizer import Conversation
+
+# Save conversation to JSON
+conv_json = conv.to_json()
+with open("conversation.json", "w") as f:
+    f.write(conv_json)
+
+# Load conversation from JSON
+with open("conversation.json", "r") as f:
+    conv_json = f.read()
+loaded_conv = Conversation.from_json(conv_json)
+```
+
+```python
+from generic_llm_memorizer import Conversation
+
+# Save conversation to JSON
+conv_json = conv.to_json()
+with open("conversation.json", "w") as f:
+    f.write(conv_json)
+
+# Load conversation from JSON
+with open("conversation.json", "r") as f:
+    conv_json = f.read()
+loaded_conv = Conversation.from_json(conv_json)
+```
+
+### Utility Functions
+
+## Extending with Custom Models
+
+You can create your own Pydantic models for domain-specific extractions:
+
+```python
+from pydantic import BaseModel
+from typing import List
+from enum import Enum
+
+class Priority(str, Enum):
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+
+class Task(BaseModel):
+    title: str
+    description: str
+    priority: Priority
+    assignee: str
+
+class TaskList(BaseModel):
+    tasks: List[Task]
+
+# Use with the generic llm_call function
+tasks = llm_call("Extract tasks from this conversation", TaskList)
+```
+
+### Advanced Usage with Structured Data Extraction
+
+The library now supports a generic `llm_call` function that works with Pydantic models for structured data extraction:
+
+```python
+from typing import Type, TypeVar
+from pydantic import BaseModel
+from generic_llm_memorizer.conversation import Conversation
+from generic_llm_memorizer.memory import Summary, Memory, Fact
+
+# Define a generic type variable bounded by BaseModel
+T = TypeVar("T", bound=BaseModel)
+
+def llm_call(prompt: str, model_class: Type[T]) -> T:
+    """
+    Generic LLM call function that returns structured data.
+    
+    Args:
+        prompt: The prompt to send to the LLM
+        model_class: The Pydantic model class to parse the response into
+        
+    Returns:
+        An instance of the specified model_class
+    """
+    # In a real implementation, this would call an actual LLM API
+    # and parse the response into the specified Pydantic model
+    
+    # Mock implementation for demonstration
+    if model_class == Summary:
+        return Summary(content="Mock summary of the conversation")
+    elif model_class == Memory:
+        return Memory(facts=[
+            Fact(
+                content="Example fact extracted from conversation",
+                kind="example",
+                timestamp="2023-01-01T10:00:00Z",
+                validity="forever"
+            )
+        ])
+    
+    # Return a default instance of the model
+    return model_class()
+
+# Usage with LLMMemorizer
+from generic_llm_memorizer.llm_memorizer import LLMMemorizer
+
+conversation = Conversation(system_prompt="You are a helpful assistant")
+conversation.add_user_message("Hello, my name is John Doe and I'm a software engineer")
+
+memorizer = LLMMemorizer(
+    user_id="user_123",
+    session_id="session_456",
+    llm_call=llm_call,
+    conversation=conversation
+)
+
+# Extract structured facts
+memory = memorizer.extract_facts()
+print(f"Extracted {len(memory.facts)} facts")
+
+# Generate structured summary
+summary = memorizer.summarize()
+print(f"Summary: {summary.content}")
+
+## API Reference
+
+```python
+from generic_llm_memorizer import extract_last_user_message, extract_last_assistant_message
+
+# Extract last user message
+last_user = extract_last_user_message(conv)
+
+# Extract last assistant message
+last_assistant = extract_last_assistant_message(conv)
+```
+
+## API Reference
+
+### Conversation Class
+
+Manages a conversation with an LLM.
+
+#### Methods
+
+- `add_message(role, content, metadata=None)`: Add a message to the conversation
+- `add_user_message(content, metadata=None)`: Add a user message
+- `add_assistant_message(content, metadata=None)`: Add an assistant message
+- `get_messages()`: Get all messages
+- `get_recent_messages(count)`: Get the most recent messages
+- `clear()`: Clear all messages
+- `to_dict()`: Convert to dictionary format
+- `to_json(indent=2)`: Convert to JSON string
+- `from_dict(data)`: Create from dictionary data
+- `from_json(json_str)`: Create from JSON string
+
+### Message Dataclass
+
+Represents a single message in a conversation.
+
+#### Attributes
+
+- `role`: Role of the message sender ("user", "assistant", "system", etc.)
+- `content`: Message content
+- `timestamp`: ISO format timestamp (automatically set)
+- `metadata`: Additional metadata dictionary
+
+### Utility Functions
+
+- `format_conversation_for_prompt(conversation)`: Format conversation for LLM API
+- `extract_last_user_message(conversation)`: Get last user message content
+- `extract_last_assistant_message(conversation)`: Get last assistant message content
+
+## License
+
+MIT

generic_llm_memorizer-0.1.0/generic_llm_memorizer/__init__.py

@@ -0,0 +1,17 @@
+"""
+Generic LLM Memorizer - LLM Conversation Management Library
+"""
+
+from .conversation import Conversation, Message, format_conversation_for_prompt, extract_last_user_message, extract_last_assistant_message
+
+__version__ = "0.1.0"
+__author__ = "Your Name"
+__email__ = "your.email@example.com"
+
+__all__ = [
+    "Conversation",
+    "Message",
+    "format_conversation_for_prompt",
+    "extract_last_user_message",
+    "extract_last_assistant_message"
+]

generic_llm_memorizer-0.1.0/generic_llm_memorizer/conversation.py

@@ -0,0 +1,170 @@
+"""
+Conversation management for LLM interactions.
+Provides classes and functions to manage LLM conversation history and context.
+"""
+
+import json
+from dataclasses import asdict, dataclass
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class Message:
+    """Represents a single message in a conversation."""
+
+    role: str  # "user", "assistant", "system", etc.
+    content: str
+    timestamp: Optional[str] = None
+    metadata: Optional[Dict[str, Any]] = None
+
+    def __post_init__(self):
+        if self.timestamp is None:
+            self.timestamp = datetime.now().isoformat()
+        if self.metadata is None:
+            self.metadata = {}
+
+
+class Conversation:
+    """Manages a conversation with an LLM."""
+
+    def __init__(self, session_id: str, system_prompt: Optional[str] = None):
+        self.session_id = session_id
+        self.messages: List[Message] = []
+
+        if system_prompt:
+            self.add_message("system", system_prompt)
+
+    def add_message(
+        self, role: str, content: str, metadata: Optional[Dict[str, Any]] = None
+    ) -> Message:
+        """Add a message to the conversation."""
+        message = Message(role=role, content=content, metadata=metadata)
+        self.messages.append(message)
+        return message
+
+    def add_messages(self, messages: List[Message]) -> None:
+        """Add multiple messages to the conversation."""
+        self.messages.extend(messages)
+
+    def insert_summary(self, summary: str) -> None:
+        """Insert a summary message into the conversation."""
+        return self.messages.insert(0, Message(role="assistant", content=summary))
+
+    def add_user_message(
+        self, content: str, metadata: Optional[Dict[str, Any]] = None
+    ) -> Message:
+        """Add a user message to the conversation."""
+        return self.add_message("user", content, metadata)
+
+    def add_assistant_message(
+        self, content: str, metadata: Optional[Dict[str, Any]] = None
+    ) -> Message:
+        """Add an assistant message to the conversation."""
+        return self.add_message("assistant", content, metadata)
+
+    def get_messages(self) -> List[Message]:
+        """Get all messages in the conversation."""
+        return self.messages.copy()
+
+    def get_recent_messages(self, count: int) -> List[Message]:
+        """Get the most recent messages."""
+        return (
+            self.messages[-count:]
+            if count <= len(self.messages)
+            else self.messages.copy()
+        )
+
+    def keep_recent_messages(self, count: int):
+        """Keep only the most recent messages."""
+        if count < 0:
+            raise ValueError("Count must be non-negative")
+        self.messages = self.messages[-count:]
+
+    def delete_old_messages(self, count: int):
+        """Delete the oldest messages from the conversation."""
+        if count < 0:
+            raise ValueError("Count must be non-negative")
+        self.messages = self.messages[count:]
+
+    def clear(self):
+        """Clear all messages from the conversation."""
+        self.messages.clear()
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert conversation to dictionary format."""
+        return {
+            "session_id": self.session_id,
+            "messages": [asdict(msg) for msg in self.messages],
+        }
+
+    def to_json(self, indent: int = 2) -> str:
+        """Convert conversation to JSON string."""
+        return json.dumps(self.to_dict(), indent=indent)
+
+    @classmethod
+    def from_dict(cls, session_id: str, data: List[Dict[str, Any]]) -> "Conversation":
+        """Create a conversation from dictionary data."""
+        conversation = cls(session_id=session_id)
+        conversation.messages = [Message(**msg_dict) for msg_dict in data]
+        return conversation
+
+    @classmethod
+    def from_json(cls, json_str: str) -> "Conversation":
+        """Create a conversation from JSON string."""
+        data = json.loads(json_str)
+        return cls.from_dict(data["session_id"], data["messages"])
+
+    def __len__(self) -> int:
+        return len(self.messages)
+
+    def __iter__(self):
+        return iter(self.messages)
+
+
+def format_conversation_for_prompt(conversation: Conversation) -> List[Dict[str, str]]:
+    """
+    Format conversation for use with LLM APIs that expect a list of message dicts.
+
+    Args:
+        conversation: Conversation object to format
+
+    Returns:
+        List of dictionaries with 'role' and 'content' keys
+    """
+    return [
+        {"role": msg.role, "content": msg.content}
+        for msg in conversation.get_messages()
+    ]
+
+
+def extract_last_user_message(conversation: Conversation) -> Optional[str]:
+    """
+    Extract the last user message from a conversation.
+
+    Args:
+        conversation: Conversation object
+
+    Returns:
+        Content of the last user message, or None if no user messages exist
+    """
+    for msg in reversed(conversation.messages):
+        if msg.role == "user":
+            return msg.content
+    return None
+
+
+def extract_last_assistant_message(conversation: Conversation) -> Optional[str]:
+    """
+    Extract the last assistant message from a conversation.
+
+    Args:
+        conversation: Conversation object
+
+    Returns:
+        Content of the last assistant message, or None if no assistant messages exist
+    """
+    for msg in reversed(conversation.messages):
+        if msg.role == "assistant":
+            return msg.content
+    return None