bot-knows 0.1.0__py3-none-any.whl

bot_knows/importers/registry.py

@@ -0,0 +1,125 @@
+"""Import adapter registry for bot_knows.
+
+This module provides a registry for dynamically registering
+and looking up chat import adapters.
+"""
+
+from bot_knows.importers.base import ChatImportAdapter
+
+__all__ = [
+    "ImportAdapterRegistry",
+]
+
+
+class ImportAdapterRegistry:
+    """Registry for chat import adapters.
+
+    Provides a centralized registry for import adapters, allowing
+    dynamic registration and lookup by source name.
+
+    Example:
+        # Register an adapter (as decorator)
+        @ImportAdapterRegistry.register
+        class MyAdapter(ChatImportAdapter):
+            ...
+
+        # Or register manually
+        ImportAdapterRegistry.register(MyAdapter)
+
+        # Create an adapter instance
+        adapter = ImportAdapterRegistry.create("my_source")
+        chats = adapter.parse(raw_data)
+    """
+
+    _adapters: dict[str, type[ChatImportAdapter]] = {}
+
+    @classmethod
+    def register(
+        cls,
+        adapter_cls: type[ChatImportAdapter],
+    ) -> type[ChatImportAdapter]:
+        """Register an adapter class.
+
+        Can be used as a decorator or called directly.
+
+        Args:
+            adapter_cls: Adapter class to register
+
+        Returns:
+            The adapter class (for use as decorator)
+
+        Raises:
+            ValueError: If adapter source_name is already registered
+        """
+        # Create instance to get source_name
+        instance = adapter_cls()
+        source_name = instance.source_name
+
+        if source_name in cls._adapters:
+            raise ValueError(f"Adapter already registered for source: {source_name}")
+
+        cls._adapters[source_name] = adapter_cls
+        return adapter_cls
+
+    @classmethod
+    def get(cls, source_name: str) -> type[ChatImportAdapter]:
+        """Get adapter class by source name.
+
+        Args:
+            source_name: Source identifier to look up
+
+        Returns:
+            Adapter class
+
+        Raises:
+            KeyError: If no adapter registered for source
+        """
+        if source_name not in cls._adapters:
+            available = ", ".join(cls._adapters.keys()) or "none"
+            raise KeyError(
+                f"No adapter registered for source: {source_name}. Available: {available}"
+            )
+        return cls._adapters[source_name]
+
+    @classmethod
+    def create(cls, source_name: str, **kwargs: object) -> ChatImportAdapter:
+        """Create adapter instance by source name.
+
+        Args:
+            source_name: Source identifier to look up
+            **kwargs: Arguments to pass to adapter constructor
+
+        Returns:
+            Adapter instance
+        """
+        adapter_cls = cls.get(source_name)
+        return adapter_cls(**kwargs)
+
+    @classmethod
+    def list_sources(cls) -> list[str]:
+        """List all registered source names.
+
+        Returns:
+            List of registered source identifiers
+        """
+        return list(cls._adapters.keys())
+
+    @classmethod
+    def is_registered(cls, source_name: str) -> bool:
+        """Check if a source has a registered adapter.
+
+        Args:
+            source_name: Source identifier to check
+
+        Returns:
+            True if registered, False otherwise
+        """
+        return source_name in cls._adapters
+
+    @classmethod
+    def clear(cls) -> None:
+        """Clear all registered adapters.
+
+        Primarily for testing purposes.
+        """
+        cls._adapters.clear()

bot_knows/infra/__init__.py

@@ -0,0 +1,5 @@
+"""Infrastructure implementations for bot_knows.
+
+This module contains concrete implementations of interfaces.
+These are internal and not part of the public API.
+"""

bot_knows/infra/llm/__init__.py

@@ -0,0 +1,6 @@
+"""LLM provider implementations for bot_knows."""
+
+from bot_knows.infra.llm.anthropic_provider import AnthropicProvider
+from bot_knows.infra.llm.openai_provider import OpenAIProvider
+
+__all__ = ["AnthropicProvider", "OpenAIProvider"]

bot_knows/infra/llm/anthropic_provider.py

@@ -0,0 +1,172 @@
+"""Anthropic LLM provider for bot_knows.
+
+This module provides the Anthropic implementation of LLM interface.
+Note: Anthropic does not provide embeddings, so this provider
+requires a separate embedding service.
+"""
+
+import json
+from typing import Any, Self
+
+from anthropic import AsyncAnthropic
+
+from bot_knows.config import LLMSettings
+from bot_knows.interfaces.llm import LLMInterface
+from bot_knows.logging import get_logger
+from bot_knows.models.chat import ChatCategory
+
+__all__ = [
+    "AnthropicProvider",
+]
+
+logger = get_logger(__name__)
+
+
+class AnthropicProvider(LLMInterface):
+    """Anthropic implementation of LLM interface.
+
+    Provides chat classification and topic extraction using
+    Anthropic's Claude API.
+
+    Note: This provider does NOT implement embedding generation.
+    Use OpenAI or another embedding provider for embeddings.
+    """
+
+    config_class = LLMSettings
+
+    def __init__(self, settings: LLMSettings) -> None:
+        """Initialize Anthropic provider.
+
+        Args:
+            settings: LLM configuration settings
+        """
+        self._settings = settings
+        api_key = settings.api_key.get_secret_value() if settings.api_key else None
+        self._client = AsyncAnthropic(api_key=api_key)
+        self._model = settings.model or "claude-sonnet-4-20250514"
+
+    @classmethod
+    async def from_config(cls, config: LLMSettings) -> Self:
+        """Factory method for BotKnows instantiation.
+
+        Args:
+            config: LLM settings
+
+        Returns:
+            AnthropicProvider instance
+        """
+        return cls(config)
+
+    @classmethod
+    async def from_dict(cls, config: dict[str, Any]) -> Self:
+        """Factory method for custom config dict.
+
+        Args:
+            config: Dictionary with LLM settings
+
+        Returns:
+            AnthropicProvider instance
+        """
+        settings = LLMSettings(**config)
+        return cls(settings)
+
+    async def close(self) -> None:
+        """Close resources (no-op for Anthropic)."""
+        pass
+
+    async def classify_chat(
+        self,
+        first_pair: tuple[str, str],
+        last_pair: tuple[str, str],
+    ) -> tuple[ChatCategory, list[str]]:
+        """Classify chat and extract tags."""
+        system_prompt = """You are a chat classifier.
+        Analyze the conversation samples and classify the chat and assign tags.
+
+Categories: coding, research, writing, brainstorming, debugging, learning, general, other
+Tags: no strick - should be subcategroy of the category.
+Respond with JSON only:
+{"category": "category_name", "tags": ["tag1", "tag2"]}"""
+
+        user_content = f"""First exchange:
+User: {first_pair[0][:500]}
+Assistant: {first_pair[1][:500]}
+
+Last exchange:
+User: {last_pair[0][:500]}
+Assistant: {last_pair[1][:500]}"""
+
+        try:
+            response = await self._client.messages.create(
+                model=self._model,
+                max_tokens=256,
+                system=system_prompt,
+                messages=[{"role": "user", "content": user_content}],
+            )
+            content = response.content[0].text if response.content else "{}"
+            # Extract JSON from response
+            result = self._parse_json_response(content)
+            category_str = result.get("category", "general").lower()
+            try:
+                category = ChatCategory(category_str)
+            except ValueError:
+                category = ChatCategory.GENERAL
+            tags = result.get("tags", [])
+            return category, tags[:5] if isinstance(tags, list) else []
+        except Exception as e:
+            logger.warning("chat_classification_failed", error=str(e))
+            return ChatCategory.GENERAL, []
+
+    async def extract_topics(
+        self,
+        user_content: str,
+        assistant_content: str,
+    ) -> list[tuple[str, float]]:
+        """Extract topic candidates from message pair."""
+        system_prompt = """Extract key topics from this conversation. Use concise canonical names.
+
+Respond with JSON only:
+{"topics": [{"name": "topic_name", "confidence": 0.9}]}
+
+Extract 0-5 topics."""
+
+        user_prompt = f"User: {user_content[:1000]}\n\nAssistant: {assistant_content[:1000]}"
+
+        try:
+            response = await self._client.messages.create(
+                model=self._model,
+                max_tokens=256,
+                system=system_prompt,
+                messages=[{"role": "user", "content": user_prompt}],
+            )
+            content = response.content[0].text if response.content else "{}"
+            result = self._parse_json_response(content)
+            topics = result.get("topics", [])
+            return [
+                (t["name"], float(t.get("confidence", 0.5)))
+                for t in topics
+                if isinstance(t, dict) and "name" in t
+            ][:5]
+        except Exception as e:
+            logger.warning("topic_extraction_failed", error=str(e))
+            return []
+
+    async def normalize_topic_name(self, extracted_name: str) -> str:
+        """Normalize topic name to canonical form."""
+        normalized = extracted_name.strip().lower()
+        normalized = " ".join(word.capitalize() for word in normalized.split())
+        return normalized[:100]
+
+    @staticmethod
+    def _parse_json_response(content: str) -> dict:
+        """Parse JSON from response, handling markdown code blocks."""
+        content = content.strip()
+        # Remove markdown code blocks if present
+        if content.startswith("```"):
+            lines = content.split("\n")
+            # Remove first and last lines (```json and ```)
+            content = "\n".join(lines[1:-1] if lines[-1] == "```" else lines[1:])
+        try:
+            return json.loads(content)
+        except json.JSONDecodeError:
+            return {}

bot_knows/infra/llm/openai_provider.py

@@ -0,0 +1,195 @@
+"""OpenAI LLM provider for bot_knows.
+
+This module provides the OpenAI implementation of LLM and embedding interfaces.
+"""
+
+import json
+from typing import Any, Self
+
+import numpy as np
+from openai import AsyncOpenAI
+
+from bot_knows.config import LLMSettings
+from bot_knows.interfaces.embedding import EmbeddingServiceInterface
+from bot_knows.interfaces.llm import LLMInterface
+from bot_knows.logging import get_logger
+from bot_knows.models.chat import ChatCategory
+
+__all__ = [
+    "OpenAIProvider",
+]
+
+logger = get_logger(__name__)
+
+
+class OpenAIProvider(LLMInterface, EmbeddingServiceInterface):
+    """OpenAI implementation of LLM and embedding interfaces.
+
+    Provides chat classification, topic extraction, and embedding
+    generation using OpenAI's API.
+    """
+
+    config_class = LLMSettings
+
+    def __init__(self, settings: LLMSettings) -> None:
+        """Initialize OpenAI provider.
+
+        Args:
+            settings: LLM configuration settings
+        """
+        self._settings = settings
+        api_key = settings.api_key.get_secret_value() if settings.api_key else None
+        self._client = AsyncOpenAI(api_key=api_key)
+        self._model = settings.model
+        self._embedding_model = settings.embedding_model
+        self._embedding_dimensions = settings.embedding_dimensions
+
+    @classmethod
+    async def from_config(cls, config: LLMSettings) -> Self:
+        """Factory method for BotKnows instantiation.
+
+        Args:
+            config: LLM settings
+
+        Returns:
+            OpenAIProvider instance
+        """
+        return cls(config)
+
+    @classmethod
+    async def from_dict(cls, config: dict[str, Any]) -> Self:
+        """Factory method for custom config dict.
+
+        Args:
+            config: Dictionary with LLM settings
+
+        Returns:
+            OpenAIProvider instance
+        """
+        settings = LLMSettings(**config)
+        return cls(settings)
+
+    async def close(self) -> None:
+        """Close resources (no-op for OpenAI)."""
+        pass
+
+    # Embedding interface
+    async def embed(self, text: str) -> list[float]:
+        """Generate embedding for text."""
+        response = await self._client.embeddings.create(
+            model=self._embedding_model,
+            input=text,
+        )
+        return response.data[0].embedding
+
+    async def embed_batch(self, texts: list[str]) -> list[list[float]]:
+        """Generate embeddings for multiple texts."""
+        if not texts:
+            return []
+        response = await self._client.embeddings.create(
+            model=self._embedding_model,
+            input=texts,
+        )
+        sorted_data = sorted(response.data, key=lambda x: x.index)
+        return [item.embedding for item in sorted_data]
+
+    async def similarity(self, embedding1: list[float], embedding2: list[float]) -> float:
+        """Compute cosine similarity between embeddings."""
+        vec1 = np.array(embedding1)
+        vec2 = np.array(embedding2)
+        norm1 = np.linalg.norm(vec1)
+        norm2 = np.linalg.norm(vec2)
+        if norm1 == 0 or norm2 == 0:
+            return 0.0
+        return float(np.dot(vec1, vec2) / (norm1 * norm2))
+
+    # LLM interface
+    async def classify_chat(
+        self,
+        first_pair: tuple[str, str],
+        last_pair: tuple[str, str],
+    ) -> tuple[ChatCategory, list[str]]:
+        """Classify chat and extract tags."""
+        system_prompt = """You are a chat classifier.
+        Analyze the conversation samples and classify the chat and assign tags.
+
+Categories: coding, research, writing, brainstorming, debugging, learning, general, other
+Tags: no strick - should be subcategroy of the category.
+Respond with JSON only:
+{"category": "category_name", "tags": ["tag1", "tag2"]}"""
+
+        user_content = f"""First exchange:
+User: {first_pair[0][:500]}
+Assistant: {first_pair[1][:500]}
+
+Last exchange:
+User: {last_pair[0][:500]}
+Assistant: {last_pair[1][:500]}"""
+
+        try:
+            response = await self._client.chat.completions.create(
+                model=self._model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_content},
+                ],
+                response_format={"type": "json_object"},
+                temperature=0.3,
+            )
+            content = response.choices[0].message.content or "{}"
+            result = json.loads(content)
+            category_str = result.get("category", "general").lower()
+            try:
+                category = ChatCategory(category_str)
+            except ValueError:
+                category = ChatCategory.GENERAL
+            tags = result.get("tags", [])
+            return category, tags[:5] if isinstance(tags, list) else []
+        except Exception as e:
+            logger.warning("chat_classification_failed", error=str(e))
+            return ChatCategory.GENERAL, []
+
+    async def extract_topics(
+        self,
+        user_content: str,
+        assistant_content: str,
+    ) -> list[tuple[str, float]]:
+        """Extract topic candidates from message pair."""
+        system_prompt = """Extract key topics from this conversation. Use concise canonical names.
+
+Respond with JSON only:
+{"topics": [{"name": "topic_name", "confidence": 0.9}]}
+
+Extract 0-5 topics."""
+
+        user_prompt = f"User: {user_content[:1000]}\n\nAssistant: {assistant_content[:1000]}"
+
+        try:
+            response = await self._client.chat.completions.create(
+                model=self._model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt},
+                ],
+                response_format={"type": "json_object"},
+                temperature=0.3,
+            )
+            content = response.choices[0].message.content or "{}"
+            result = json.loads(content)
+            topics = result.get("topics", [])
+            return [
+                (t["name"], float(t.get("confidence", 0.5)))
+                for t in topics
+                if isinstance(t, dict) and "name" in t
+            ][:5]
+        except Exception as e:
+            logger.warning("topic_extraction_failed", error=str(e))
+            return []
+
+    async def normalize_topic_name(self, extracted_name: str) -> str:
+        """Normalize topic name to canonical form."""
+        # Simple normalization: lowercase, strip, limit length
+        normalized = extracted_name.strip().lower()
+        # Capitalize first letter of each word
+        normalized = " ".join(word.capitalize() for word in normalized.split())
+        return normalized[:100]

bot_knows/infra/mongo/__init__.py

@@ -0,0 +1,5 @@
+"""MongoDB infrastructure for bot_knows."""
+
+from bot_knows.infra.mongo.client import MongoClient
+
+__all__ = ["MongoClient"]

bot_knows/infra/mongo/client.py

@@ -0,0 +1,145 @@
+"""MongoDB client for bot_knows.
+
+This module provides an async MongoDB client wrapper using Motor.
+"""
+
+from typing import Any
+
+from motor.motor_asyncio import AsyncIOMotorClient, AsyncIOMotorCollection, AsyncIOMotorDatabase
+
+from bot_knows.config import MongoSettings
+from bot_knows.logging import get_logger
+
+__all__ = [
+    "MongoClient",
+]
+
+logger = get_logger(__name__)
+
+
+class MongoClient:
+    """Async MongoDB client wrapper.
+
+    Provides a connection manager and collection accessors
+    for the bot_knows MongoDB database.
+
+    Example:
+        client = MongoClient(settings)
+        await client.connect()
+
+        # Access collections
+        await client.chats.insert_one(chat_data)
+
+        await client.disconnect()
+    """
+
+    def __init__(self, settings: MongoSettings) -> None:
+        """Initialize client with settings.
+
+        Args:
+            settings: MongoDB connection settings
+        """
+        self._settings = settings
+        self._client: AsyncIOMotorClient[dict[str, Any]] | None = None
+        self._db: AsyncIOMotorDatabase[dict[str, Any]] | None = None
+
+    async def connect(self) -> None:
+        """Initialize connection to MongoDB."""
+        if self._client is not None:
+            return
+
+        uri = self._settings.uri.get_secret_value()
+        self._client = AsyncIOMotorClient(uri)
+        self._db = self._client[self._settings.database]
+
+        # Verify connection
+        await self._client.admin.command("ping")
+        logger.info(
+            "connected_to_mongodb",
+            database=self._settings.database,
+        )
+
+    async def disconnect(self) -> None:
+        """Close connection to MongoDB."""
+        if self._client:
+            self._client.close()
+            self._client = None
+            self._db = None
+            logger.info("disconnected_from_mongodb")
+
+    @property
+    def db(self) -> AsyncIOMotorDatabase[dict[str, Any]]:
+        """Get database instance.
+
+        Raises:
+            RuntimeError: If not connected
+        """
+        if self._db is None:
+            raise RuntimeError("MongoClient not connected. Call connect() first.")
+        return self._db
+
+    def _collection(self, name: str) -> AsyncIOMotorCollection[dict[str, Any]]:
+        """Get collection with optional prefix."""
+        full_name = f"{self._settings.collection_prefix}{name}"
+        return self.db[full_name]
+
+    @property
+    def chats(self) -> AsyncIOMotorCollection[dict[str, Any]]:
+        """Get chats collection."""
+        return self._collection("chats")
+
+    @property
+    def messages(self) -> AsyncIOMotorCollection[dict[str, Any]]:
+        """Get messages collection."""
+        return self._collection("messages")
+
+    @property
+    def topics(self) -> AsyncIOMotorCollection[dict[str, Any]]:
+        """Get topics collection."""
+        return self._collection("topics")
+
+    @property
+    def evidence(self) -> AsyncIOMotorCollection[dict[str, Any]]:
+        """Get topic_evidence collection."""
+        return self._collection("topic_evidence")
+
+    @property
+    def recall_states(self) -> AsyncIOMotorCollection[dict[str, Any]]:
+        """Get recall_states collection."""
+        return self._collection("recall_states")
+
+    async def create_indexes(self) -> None:
+        """Create indexes for all collections."""
+        # Chats indexes
+        await self.chats.create_index("id", unique=True)
+        await self.chats.create_index("source")
+        await self.chats.create_index("created_on")
+
+        # Messages indexes
+        await self.messages.create_index("message_id", unique=True)
+        await self.messages.create_index("chat_id")
+        await self.messages.create_index("created_on")
+
+        # Topics indexes
+        await self.topics.create_index("topic_id", unique=True)
+        await self.topics.create_index("canonical_name")
+
+        # Evidence indexes
+        await self.evidence.create_index("evidence_id", unique=True)
+        await self.evidence.create_index("topic_id")
+        await self.evidence.create_index("source_message_id")
+
+        # Recall states indexes
+        await self.recall_states.create_index("topic_id", unique=True)
+        await self.recall_states.create_index("strength")
+
+        logger.info("created_mongodb_indexes")
+
+    async def __aenter__(self) -> "MongoClient":
+        """Async context manager entry."""
+        await self.connect()
+        return self
+
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        """Async context manager exit."""
+        await self.disconnect()