Initial commit

Author: anajmi07

cx-agent-backend/Dockerfile

@@ -0,0 +1,25 @@
+# Use ARM64 Python 3.11 base image with uv pre-installed
+FROM --platform=linux/arm64 ghcr.io/astral-sh/uv:python3.11-bookworm-slim
+
+# Set working directory
+WORKDIR /app
+
+# Configure uv to install packages globally and compile bytecode for performance
+ENV UV_PROJECT_ENVIRONMENT="/usr/local/"
+ENV UV_COMPILE_BYTECODE=1
+
+# Copy dependency configuration and install Python dependencies
+COPY pyproject.toml .
+RUN uv sync
+
+# Copy application source code
+COPY src/ ./src/
+
+# Set Python path
+ENV PYTHONPATH="/app/src"
+
+# Expose FastAPI server port
+EXPOSE 8080
+
+# Start the CX Agent service
+CMD ["python", "src/run.py"]

cx-agent-backend/pyproject.toml

@@ -1 +1,45 @@
+[project]
+name = "cx-agent-backend"
+version = "0.1.0"
+description = "Clean Architecture CX Agent Backend"
+requires-python = ">=3.11"
+dependencies = [
+    "fastapi>=0.104.0",
+    "uvicorn[standard]>=0.24.0",
+    "pydantic>=2.5.0",
+    "pydantic-settings>=2.1.0",
+    "langchain>=0.1.0",
+    "langchain-core>=0.1.0",
+    "langchain-openai>=0.1.0",
+    "langchain-aws>=0.1.0",
+    "langgraph>=0.1.0",
+    "langfuse>=2.0.0",
+    "boto3>=1.34.0",
+    "structlog>=23.2.0",
+    "dependency-injector>=4.41.0",
+    "tavily-python>=0.3.0",
+]
 
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.4.0",
+    "pytest-asyncio>=0.21.0",
+    "httpx>=0.25.0",
+    "ruff>=0.1.0",
+    "mypy>=1.7.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src"]
+
+[tool.ruff]
+target-version = "py311"
+line-length = 88
+
+[tool.mypy]
+python_version = "3.11"
+strict = true

cx-agent-backend/src/domain/__init__.py

@@ -0,0 +1 @@
+# Domain layer

cx-agent-backend/src/domain/entities/conversation.py

@@ -0,0 +1,104 @@
+"""Domain entities for conversation management."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from enum import Enum
+from typing import Any
+from uuid import UUID, uuid4
+
+
+class MessageRole(str, Enum):
+    """Message role enumeration."""
+
+    USER = "user"
+    ASSISTANT = "assistant"
+    SYSTEM = "system"
+
+
+class ConversationStatus(str, Enum):
+    """Conversation status enumeration."""
+
+    ACTIVE = "active"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+@dataclass(frozen=True)
+class Message:
+    """Immutable message entity."""
+
+    id: UUID
+    content: str
+    role: MessageRole
+    timestamp: datetime
+    metadata: dict[str, Any]
+
+    @classmethod
+    def create_user_message(
+        cls, content: str, metadata: dict[str, Any] | None = None
+    ) -> "Message":
+        """Create a user message."""
+        return cls(
+            id=uuid4(),
+            content=content,
+            role=MessageRole.USER,
+            timestamp=datetime.utcnow(),
+            metadata=metadata or {},
+        )
+
+    @classmethod
+    def create_assistant_message(
+        cls, content: str, metadata: dict[str, Any] | None = None
+    ) -> "Message":
+        """Create an assistant message."""
+        return cls(
+            id=uuid4(),
+            content=content,
+            role=MessageRole.ASSISTANT,
+            timestamp=datetime.utcnow(),
+            metadata=metadata or {},
+        )
+
+
+@dataclass
+class Conversation:
+    """Mutable conversation aggregate."""
+
+    id: UUID
+    user_id: str
+    messages: list[Message]
+    status: ConversationStatus
+    created_at: datetime
+    updated_at: datetime
+    metadata: dict[str, Any]
+
+    @classmethod
+    def create(
+        cls, user_id: str, metadata: dict[str, Any] | None = None
+    ) -> "Conversation":
+        """Create a new conversation."""
+        now = datetime.utcnow()
+        return cls(
+            id=uuid4(),
+            user_id=user_id,
+            messages=[],
+            status=ConversationStatus.ACTIVE,
+            created_at=now,
+            updated_at=now,
+            metadata=metadata or {},
+        )
+
+    def add_message(self, message: Message) -> None:
+        """Add a message to the conversation."""
+        self.messages.append(message)
+        self.updated_at = datetime.utcnow()
+
+    def complete(self) -> None:
+        """Mark conversation as completed."""
+        self.status = ConversationStatus.COMPLETED
+        self.updated_at = datetime.utcnow()
+
+    def fail(self) -> None:
+        """Mark conversation as failed."""
+        self.status = ConversationStatus.FAILED
+        self.updated_at = datetime.utcnow()

cx-agent-backend/src/domain/ports/secret_reader.py

@@ -0,0 +1,8 @@
+from abc import ABC, abstractmethod
+
+
+class SecretReader(ABC):
+    @abstractmethod
+    def read_secret(self, name: str) -> str:
+        """Get secret value by name."""
+        pass

cx-agent-backend/src/domain/repositories/conversation_repository.py

@@ -0,0 +1,30 @@
+"""Repository interfaces for conversation management."""
+
+from abc import ABC, abstractmethod
+from uuid import UUID
+
+from domain.entities.conversation import Conversation
+
+
+class ConversationRepository(ABC):
+    """Abstract repository for conversation persistence."""
+
+    @abstractmethod
+    async def save(self, conversation: Conversation) -> None:
+        """Save a conversation."""
+        pass
+
+    @abstractmethod
+    async def get_by_id(self, conversation_id: UUID) -> Conversation | None:
+        """Get conversation by ID."""
+        pass
+
+    @abstractmethod
+    async def get_by_user_id(self, user_id: str) -> list[Conversation]:
+        """Get conversations by user ID."""
+        pass
+
+    @abstractmethod
+    async def delete(self, conversation_id: UUID) -> None:
+        """Delete a conversation."""
+        pass

cx-agent-backend/src/domain/services/agent_service.py

@@ -0,0 +1,49 @@
+"""Domain service interface for agent operations."""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from enum import Enum
+
+from domain.entities.conversation import Message
+
+
+class AgentType(str, Enum):
+    """Supported agent types."""
+
+    CUSTOMER_SERVICE = "customer_service"
+    RESEARCH = "research"
+    GENERAL = "general"
+
+
+@dataclass(frozen=True)
+class AgentRequest:
+    """Request for agent processing."""
+
+    messages: list[Message]
+    agent_type: AgentType
+    user_id: str
+    model: str
+    session_id: str | None = None
+
+
+@dataclass(frozen=True)
+class AgentResponse:
+    ("""Response from agent processing.""",)
+    content: str
+    agent_type: AgentType
+    tools_used: list[str]
+    metadata: dict[str, str]
+
+
+class AgentService(ABC):
+    """Abstract service for agent operations."""
+
+    @abstractmethod
+    async def process_request(self, request: AgentRequest) -> AgentResponse:
+        """Process request through agent."""
+        pass
+
+    @abstractmethod
+    async def stream_response(self, request: AgentRequest):
+        """Stream response from agent."""
+        pass