genxai-framework 0.1.0__py3-none-any.whl

genxai/core/graph/trigger_runner.py

@@ -0,0 +1,40 @@
+"""Trigger-driven workflow execution utilities."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+import logging
+
+from genxai.core.graph.executor import WorkflowExecutor
+from genxai.triggers.base import TriggerEvent
+
+logger = logging.getLogger(__name__)
+
+
+class TriggerWorkflowRunner:
+    """Bind trigger events to workflow execution."""
+
+    def __init__(
+        self,
+        nodes: List[Dict[str, Any]],
+        edges: List[Dict[str, Any]],
+        openai_api_key: Optional[str] = None,
+        anthropic_api_key: Optional[str] = None,
+    ) -> None:
+        self.nodes = nodes
+        self.edges = edges
+        self.executor = WorkflowExecutor(
+            openai_api_key=openai_api_key,
+            anthropic_api_key=anthropic_api_key,
+        )
+
+    async def handle_event(self, event: TriggerEvent) -> Dict[str, Any]:
+        """Execute the workflow using the trigger event payload as input."""
+        logger.info("Trigger event received: %s", event.trigger_id)
+        input_data = event.payload or {}
+        result = await self.executor.execute(
+            nodes=self.nodes,
+            edges=self.edges,
+            input_data=input_data,
+        )
+        return result

genxai/core/memory/__init__.py

@@ -0,0 +1,19 @@
+"""Memory system for GenXAI agents."""
+
+from genxai.core.memory.base import Memory, MemoryType, MemoryConfig
+from genxai.core.memory.short_term import ShortTermMemory
+from genxai.core.memory.shared import SharedMemoryBus
+from genxai.core.memory.long_term import LongTermMemory
+from genxai.core.memory.manager import MemorySystem
+from genxai.core.memory.persistence import MemoryPersistenceConfig, JsonMemoryStore
+
+__all__ = [
+    "Memory",
+    "MemoryType",
+    "MemoryConfig",
+    "ShortTermMemory",
+    "LongTermMemory",
+    "MemorySystem",
+    "MemoryPersistenceConfig",
+    "JsonMemoryStore",
+]

genxai/core/memory/base.py

@@ -0,0 +1,72 @@
+"""Base memory classes and types."""
+
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel, Field, ConfigDict
+from datetime import datetime
+from enum import Enum
+
+
+class MemoryType(str, Enum):
+    """Types of memory."""
+
+    SHORT_TERM = "short_term"
+    LONG_TERM = "long_term"
+    EPISODIC = "episodic"
+    SEMANTIC = "semantic"
+    PROCEDURAL = "procedural"
+    WORKING = "working"
+
+
+class Memory(BaseModel):
+    """Base memory unit."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    id: str
+    type: MemoryType
+    content: Any
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+    timestamp: datetime
+    importance: float = Field(default=0.5, ge=0.0, le=1.0)
+    access_count: int = 0
+    # Default to "now" so callers don't have to provide it explicitly.
+    last_accessed: datetime = Field(default_factory=datetime.now)
+    embedding: Optional[List[float]] = None
+    tags: List[str] = Field(default_factory=list)
+
+
+    def __repr__(self) -> str:
+        """String representation."""
+        return f"Memory(id={self.id}, type={self.type}, importance={self.importance})"
+
+
+class MemoryConfig(BaseModel):
+    """Configuration for memory system."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    # Capacity settings
+    short_term_capacity: int = Field(default=20, ge=1)
+    working_capacity: int = Field(default=5, ge=1)
+
+    # Feature flags
+    long_term_enabled: bool = True
+    episodic_enabled: bool = True
+    semantic_enabled: bool = True
+    procedural_enabled: bool = True
+
+    # Storage backends
+    vector_db: Optional[str] = "pinecone"
+    graph_db: Optional[str] = "neo4j"
+    cache_db: Optional[str] = "redis"
+
+    # Consolidation settings
+    consolidation_enabled: bool = True
+    consolidation_schedule: str = "0 2 * * *"  # Daily at 2 AM
+    importance_threshold: float = Field(default=0.7, ge=0.0, le=1.0)
+    retention_days: int = Field(default=365, ge=1)
+
+    # Embedding settings
+    embedding_model: str = "text-embedding-ada-002"
+    embedding_dimension: int = 1536
+

genxai/core/memory/embedding.py

@@ -0,0 +1,327 @@
+"""Embedding service for memory vectorization."""
+
+from typing import List, Optional, Union
+from abc import ABC, abstractmethod
+import logging
+import os
+
+logger = logging.getLogger(__name__)
+
+
+class EmbeddingService(ABC):
+    """Abstract base class for embedding services."""
+
+    @abstractmethod
+    async def embed(self, text: Union[str, List[str]]) -> Union[List[float], List[List[float]]]:
+        """Generate embeddings for text.
+
+        Args:
+            text: Single text string or list of texts
+
+        Returns:
+            Single embedding or list of embeddings
+        """
+        pass
+
+    @abstractmethod
+    def get_dimension(self) -> int:
+        """Get embedding dimension."""
+        pass
+
+
+class OpenAIEmbeddingService(EmbeddingService):
+    """OpenAI embedding service."""
+
+    def __init__(
+        self,
+        model: str = "text-embedding-ada-002",
+        api_key: Optional[str] = None,
+    ) -> None:
+        """Initialize OpenAI embedding service.
+
+        Args:
+            model: OpenAI embedding model
+            api_key: OpenAI API key (or set OPENAI_API_KEY env var)
+        """
+        self.model = model
+        self.api_key = api_key or os.getenv("OPENAI_API_KEY")
+        self._client = None
+        self._initialized = False
+
+        # Model dimensions
+        self._dimensions = {
+            "text-embedding-ada-002": 1536,
+            "text-embedding-3-small": 1536,
+            "text-embedding-3-large": 3072,
+        }
+
+    async def _ensure_initialized(self) -> None:
+        """Ensure OpenAI client is initialized."""
+        if self._initialized:
+            return
+
+        try:
+            from openai import AsyncOpenAI
+
+            if not self.api_key:
+                raise ValueError(
+                    "OpenAI API key required. Set OPENAI_API_KEY env var."
+                )
+
+            self._client = AsyncOpenAI(api_key=self.api_key)
+            self._initialized = True
+            logger.info(f"Initialized OpenAI embedding service: {self.model}")
+
+        except ImportError:
+            logger.error(
+                "OpenAI not installed. Install with: pip install openai"
+            )
+            raise RuntimeError("OpenAI not available")
+        except Exception as e:
+            logger.error(f"Failed to initialize OpenAI: {e}")
+            raise
+
+    async def embed(self, text: Union[str, List[str]]) -> Union[List[float], List[List[float]]]:
+        """Generate embeddings for text."""
+        await self._ensure_initialized()
+
+        try:
+            # Handle single text vs batch
+            is_single = isinstance(text, str)
+            texts = [text] if is_single else text
+
+            # Generate embeddings
+            response = await self._client.embeddings.create(
+                model=self.model,
+                input=texts,
+            )
+
+            # Extract embeddings
+            embeddings = [item.embedding for item in response.data]
+
+            # Return single embedding or list
+            return embeddings[0] if is_single else embeddings
+
+        except Exception as e:
+            logger.error(f"Failed to generate embeddings: {e}")
+            raise
+
+    def get_dimension(self) -> int:
+        """Get embedding dimension."""
+        return self._dimensions.get(self.model, 1536)
+
+
+class LocalEmbeddingService(EmbeddingService):
+    """Local embedding service using sentence-transformers."""
+
+    def __init__(
+        self,
+        model: str = "all-MiniLM-L6-v2",
+        device: Optional[str] = None,
+    ) -> None:
+        """Initialize local embedding service.
+
+        Args:
+            model: Sentence-transformers model name
+            device: Device to use ('cpu', 'cuda', or None for auto)
+        """
+        self.model_name = model
+        self.device = device
+        self._model = None
+        self._initialized = False
+
+        # Common model dimensions
+        self._dimensions = {
+            "all-MiniLM-L6-v2": 384,
+            "all-mpnet-base-v2": 768,
+            "all-MiniLM-L12-v2": 384,
+        }
+
+    async def _ensure_initialized(self) -> None:
+        """Ensure model is loaded."""
+        if self._initialized:
+            return
+
+        try:
+            from sentence_transformers import SentenceTransformer
+
+            self._model = SentenceTransformer(self.model_name, device=self.device)
+            self._initialized = True
+            logger.info(f"Initialized local embedding model: {self.model_name}")
+
+        except ImportError:
+            logger.error(
+                "sentence-transformers not installed. "
+                "Install with: pip install sentence-transformers"
+            )
+            raise RuntimeError("sentence-transformers not available")
+        except Exception as e:
+            logger.error(f"Failed to load model: {e}")
+            raise
+
+    async def embed(self, text: Union[str, List[str]]) -> Union[List[float], List[List[float]]]:
+        """Generate embeddings for text."""
+        await self._ensure_initialized()
+
+        try:
+            # Handle single text vs batch
+            is_single = isinstance(text, str)
+            texts = [text] if is_single else text
+
+            # Generate embeddings
+            embeddings = self._model.encode(texts, convert_to_numpy=True)
+
+            # Convert to list
+            embeddings = embeddings.tolist()
+
+            # Return single embedding or list
+            return embeddings[0] if is_single else embeddings
+
+        except Exception as e:
+            logger.error(f"Failed to generate embeddings: {e}")
+            raise
+
+    def get_dimension(self) -> int:
+        """Get embedding dimension."""
+        if self._initialized and self._model:
+            return self._model.get_sentence_embedding_dimension()
+        return self._dimensions.get(self.model_name, 384)
+
+
+class CohereEmbeddingService(EmbeddingService):
+    """Cohere embedding service."""
+
+    def __init__(
+        self,
+        model: str = "embed-english-v3.0",
+        api_key: Optional[str] = None,
+        input_type: str = "search_document",
+    ) -> None:
+        """Initialize Cohere embedding service.
+
+        Args:
+            model: Cohere embedding model
+            api_key: Cohere API key (or set COHERE_API_KEY env var)
+            input_type: Input type ('search_document', 'search_query', 'classification', 'clustering')
+        """
+        self.model = model
+        self.api_key = api_key or os.getenv("COHERE_API_KEY")
+        self.input_type = input_type
+        self._client = None
+        self._initialized = False
+
+        # Model dimensions
+        self._dimensions = {
+            "embed-english-v3.0": 1024,
+            "embed-english-light-v3.0": 384,
+            "embed-multilingual-v3.0": 1024,
+        }
+
+    async def _ensure_initialized(self) -> None:
+        """Ensure Cohere client is initialized."""
+        if self._initialized:
+            return
+
+        try:
+            import cohere
+
+            if not self.api_key:
+                raise ValueError(
+                    "Cohere API key required. Set COHERE_API_KEY env var."
+                )
+
+            self._client = cohere.AsyncClient(api_key=self.api_key)
+            self._initialized = True
+            logger.info(f"Initialized Cohere embedding service: {self.model}")
+
+        except ImportError:
+            logger.error(
+                "Cohere not installed. Install with: pip install cohere"
+            )
+            raise RuntimeError("Cohere not available")
+        except Exception as e:
+            logger.error(f"Failed to initialize Cohere: {e}")
+            raise
+
+    async def embed(self, text: Union[str, List[str]]) -> Union[List[float], List[List[float]]]:
+        """Generate embeddings for text."""
+        await self._ensure_initialized()
+
+        try:
+            # Handle single text vs batch
+            is_single = isinstance(text, str)
+            texts = [text] if is_single else text
+
+            # Generate embeddings
+            response = await self._client.embed(
+                texts=texts,
+                model=self.model,
+                input_type=self.input_type,
+            )
+
+            # Extract embeddings
+            embeddings = response.embeddings
+
+            # Return single embedding or list
+            return embeddings[0] if is_single else embeddings
+
+        except Exception as e:
+            logger.error(f"Failed to generate embeddings: {e}")
+            raise
+
+    def get_dimension(self) -> int:
+        """Get embedding dimension."""
+        return self._dimensions.get(self.model, 1024)
+
+
+class EmbeddingServiceFactory:
+    """Factory for creating embedding services."""
+
+    _services = {
+        "openai": OpenAIEmbeddingService,
+        "local": LocalEmbeddingService,
+        "cohere": CohereEmbeddingService,
+    }
+
+    @classmethod
+    def create(
+        cls,
+        provider: str,
+        **kwargs
+    ) -> EmbeddingService:
+        """Create an embedding service instance.
+
+        Args:
+            provider: Embedding provider ("openai", "local", "cohere")
+            **kwargs: Provider-specific arguments
+
+        Returns:
+            EmbeddingService instance
+
+        Raises:
+            ValueError: If provider is not supported
+        """
+        if provider not in cls._services:
+            raise ValueError(
+                f"Unsupported embedding provider: {provider}. "
+                f"Supported: {list(cls._services.keys())}"
+            )
+
+        service_class = cls._services[provider]
+        return service_class(**kwargs)
+
+    @classmethod
+    def register(cls, name: str, service_class: type) -> None:
+        """Register a custom embedding service.
+
+        Args:
+            name: Name of the service
+            service_class: Embedding service class
+        """
+        cls._services[name] = service_class
+        logger.info(f"Registered embedding service: {name}")
+
+    @classmethod
+    def list_providers(cls) -> List[str]:
+        """List available embedding providers."""
+        return list(cls._services.keys())