Make all code participate in dependency injection

README.MD

@@ -1,5 +1,10 @@
 # CTP Slack Bot
 
+## _Modus Operandi_ in a Nutshell
+
+* Intelligently responds to Slack messages based on a repository of data.
+* Periodically checks for new content to add to its repository.
+
 ## Tech Stack
 
 * Hugging Face Spaces for hosting and serverless API
@@ -7,7 +12,10 @@
 * MongoDB for data persistence
 * Docker for containerization
 * Python
-    * See `pyproject.toml` for Python packages.
+    * FastAPI for serving HTTP requests
+    * httpx for making HTTP requests
+    * APScheduler for running periodic tasks in the background
+    * See `pyproject.toml` for additional Python packages.
 
 ## General Project Structure
 
@@ -26,7 +34,8 @@
 * `scripts/`: utility scripts for development, deployment, etc.
     * `run-dev.sh`: script to run the application locally
 * `notebooks/`: Jupyter notebooks for exploration and model development
-* `.env`: local environment variables for development purposes
+* `.env`: local environment variables for development purposes (to be created for local use only from `.env.template`)
+* `Dockerfile`: Docker container build definition
 
 ## How to Run the Application
 

src/ctp_slack_bot/__init__.py

@@ -0,0 +1 @@
+from ctp_slack_bot.containers import Container

src/ctp_slack_bot/api/__init__.py

@@ -0,0 +1 @@
+from ctp_slack_bot.api.main import app, run

src/ctp_slack_bot/api/main.py

@@ -4,12 +4,11 @@ from loguru import logger
 from typing import AsyncGenerator
 from dependency_injector.wiring import inject, Provide
 
+from ctp_slack_bot import Container
 from ctp_slack_bot.api.routes import router
-from ctp_slack_bot.core.config import Settings
-from ctp_slack_bot.core.logging import setup_logging
+from ctp_slack_bot.core import Settings, setup_logging
 from ctp_slack_bot.core.response_rendering import PrettyJSONResponse
-from ctp_slack_bot.tasks.scheduler import start_scheduler, stop_scheduler
-from ctp_slack_bot.containers import Container
+from ctp_slack_bot.tasks import start_scheduler, stop_scheduler
 
 @asynccontextmanager
 async def lifespan(app: FastAPI) -> AsyncGenerator:
@@ -19,14 +18,8 @@ async def lifespan(app: FastAPI) -> AsyncGenerator:
     """
     # Initialize container and wire the container to modules that need dependency injection.
     container = Container()
+    container.wire(packages=['ctp_slack_bot'])
     app.container = container
-    container.wire(
-        modules=[
-            "ctp_slack_bot.api.routes",
-            "ctp_slack_bot.services",
-            "ctp_slack_bot.tasks"
-        ]
-    )
 
     # Setup logging.
     setup_logging(container)

src/ctp_slack_bot/api/routes.py

@@ -2,18 +2,17 @@ from fastapi import APIRouter, Depends, HTTPException, status
 from dependency_injector.wiring import inject, Provide
 from loguru import logger
 
-from ctp_slack_bot.containers import Container
-#from ctp_slack_bot.api.dependencies import get_slack_service, get_transcript_service
-from ctp_slack_bot.core.config import Settings
-#from ctp_slack_bot.models.transcript import TranscriptRequest, TranscriptResponse
-#from ctp_slack_bot.services.slack_service import SlackService
-#from ctp_slack_bot.services.transcript_service import TranscriptService
+from ctp_slack_bot import Container
+from ctp_slack_bot.core import Settings
+from ctp_slack_bot.services import SlackService
 
 router = APIRouter(prefix="/api/v1")
 
 @router.get("/env", response_model=Settings)
 @inject
 async def get_env(settings: Settings = Depends(Provide[Container.settings])) -> Settings:
+    if not settings.DEBUG:
+        raise HTTPException(status_code=404)
     return settings
 
 # @router.post("/transcripts/analyze", response_model=TranscriptResponse)

src/ctp_slack_bot/containers.py

@@ -1,43 +1,25 @@
 from dependency_injector.containers import DeclarativeContainer
-from dependency_injector.providers import Configuration, Factory, Singleton
-#from pymongo import MongoClient
-#from langchain.embeddings import HuggingFaceEmbeddings
-#from transformers import AutoTokenizer, AutoModel
+from dependency_injector.providers import Factory, Singleton
+from openai import OpenAI
 
 from ctp_slack_bot.core.config import Settings
-#from ctp_slack_bot.db.connection import get_database
-#from ctp_slack_bot.services.vectorization_service import VectorizationService
+from ctp_slack_bot.db.mongo_db import MongoDB
+from ctp_slack_bot.services.answer_retrieval_service import AnswerRetrievalService
+from ctp_slack_bot.services.content_ingestion_service import ContentIngestionService
+from ctp_slack_bot.services.context_retrieval_service import ContextRetrievalService
+from ctp_slack_bot.services.event_brokerage_service import EventBrokerageService
+from ctp_slack_bot.services.question_dispatch_service import QuestionDispatchService
+from ctp_slack_bot.services.slack_service import SlackService
+from ctp_slack_bot.services.vector_database_service import VectorDatabaseService
+from ctp_slack_bot.services.vectorization_service import VectorizationService
+
 
 class Container(DeclarativeContainer):
-    # Core dependencies
     settings = Singleton(Settings)
 
-    # db_client = Singleton(
-    #     MongoClient,
-    #     host=config.MONGODB_URI.get_secret_value
-    # )
-
-    # db = Singleton(
-    #     get_database,
-    #     client=db_client,
-    #     db_name=config.MONGODB_NAME
-    # )
-
-    # Machine-learning models
-    # tokenizer = Singleton(
-    #     AutoTokenizer.from_pretrained,
-    #     config.EMBEDDING_MODEL
-    # )
-
-    # model = Singleton(
-    #     AutoModel.from_pretrained,
-    #     config.EMBEDDING_MODEL
-    # )
+    event_brokerage_service = Singleton(EventBrokerageService)
 
-    # embeddings = Singleton(
-    #     HuggingFaceEmbeddings,
-    #     model_name=config.EMBEDDING_MODEL
-    # )
+    mongo_db = Singleton(MongoDB, settings=settings)
 
     # Repositories
     # transcript_repository = Factory(
@@ -45,15 +27,18 @@ class Container(DeclarativeContainer):
     #     db=db
     # )
 
-    # Services
-    # vectorization_service = Factory(
-    #     VectorizationService,
-    #     embeddings=embeddings,
-    #     chunk_size=config.CHUNK_SIZE,
-    #     chunk_overlap=config.CHUNK_OVERLAP,
-    #     vector_dimension=config.VECTOR_DIMENSION
-    # )
+    open_ai_client = Factory(OpenAI, api_key=settings.provided.OPENAI_API_KEY) # TODO: poor practice to do it this way; create a LanguageModelService that creates an OpenAI client.
+
+    vector_database_service = Singleton(VectorDatabaseService, settings=settings, mongo_db=mongo_db)
+
+    vectorization_service = Singleton(VectorizationService, settings=settings, client=open_ai_client)
+
+    content_ingestion_service = Singleton(ContentIngestionService, settings=settings, event_brokerage_service=event_brokerage_service, vector_database_service=vector_database_service, vectorization_service=vectorization_service)
+
+    context_retrieval_service = Singleton(ContextRetrievalService, settings=settings, vectorization_service=vectorization_service, vector_database_service=vector_database_service)
+
+    answer_retrieval_service = Singleton(AnswerRetrievalService, settings=settings, event_brokerage_service=event_brokerage_service, client=open_ai_client)
+
+    question_dispatch_service = Singleton(QuestionDispatchService, settings=settings, event_brokerage_service=event_brokerage_service, content_ingestion_service=content_ingestion_service, context_retrieval_service=context_retrieval_service, answer_retrieval_service=answer_retrieval_service)
 
-    # Add other services here
-    # transcript_service = providers.Factory(...)
-    # slack_service = providers.Factory(...)
+    slack_service = Singleton(SlackService, settings=settings, event_brokerage_service=event_brokerage_service)

src/ctp_slack_bot/core/__init__.py

@@ -0,0 +1,2 @@
+from ctp_slack_bot.core.config import Settings
+from ctp_slack_bot.core.logging import logger, setup_logging

src/ctp_slack_bot/core/logging.py

@@ -3,9 +3,6 @@ from loguru import logger
 from sys import stderr
 from typing import Dict, Union
 
-from ctp_slack_bot.containers import Container
-
-
 class InterceptHandler(Handler):
     """
     Intercept standard logging messages toward Loguru.
@@ -32,7 +29,7 @@ class InterceptHandler(Handler):
         )
 
 
-def setup_logging(container: Container) -> None:
+def setup_logging(container: "Container") -> None:
     """
     Configure logging with Loguru.
     
@@ -40,6 +37,7 @@ def setup_logging(container: Container) -> None:
     configures the log format based on settings, and intercepts
     standard logging messages.
     """
+    from ctp_slack_bot import Container
     settings = container.settings() if container else Provide[Container.settings]
 
     # Remove default loguru handler

src/ctp_slack_bot/db/MongoDB.py

@@ -1,122 +0,0 @@
-from motor.motor_asyncio import AsyncIOMotorClient
-from pymongo import IndexModel, ASCENDING
-import logging
-from typing import Optional
-
-from ctp_slack_bot.core.config import settings
-
-logger = logging.getLogger(__name__)
-
-class MongoDB:
-    """
-    MongoDB connection and initialization class.
-    Handles connection to MongoDB, database selection, and index creation.
-    """
-    def __init__(self):
-        self.client: Optional[AsyncIOMotorClient] = None
-        self.db = None
-        self.vector_collection = None
-        self.initialized = False
-
-    async def connect(self):
-        """
-        Connect to MongoDB using connection string from settings.
-        """
-        if self.client is not None:
-            return
-
-        if not settings.MONGODB_URI:
-            raise ValueError("MONGODB_URI is not set in environment variables")
-
-        try:
-            # Create MongoDB connection
-            self.client = AsyncIOMotorClient(settings.MONGODB_URI.get_secret_value())
-            self.db = self.client[settings.MONGODB_DB_NAME]
-            self.vector_collection = self.db["vector_store"]
-            logger.info(f"Connected to MongoDB: {settings.MONGODB_DB_NAME}")
-        except Exception as e:
-            logger.error(f"Error connecting to MongoDB: {str(e)}")
-            raise
-
-    async def initialize(self):
-        """
-        Initialize MongoDB with required collections and indexes.
-        """
-        if self.initialized:
-            return
-        
-        if not self.client:
-            await self.connect()
-        
-        try:
-            # Create vector index for similarity search
-            await self.create_vector_index()
-            self.initialized = True
-            logger.info("MongoDB initialized successfully")
-        except Exception as e:
-            logger.error(f"Error initializing MongoDB: {str(e)}")
-            raise
-
-    async def create_vector_index(self):
-        """
-        Create vector index for similarity search using MongoDB Atlas Vector Search.
-        """
-        try:
-            # Check if index already exists
-            existing_indexes = await self.vector_collection.list_indexes().to_list(length=None)
-            index_names = [index.get('name') for index in existing_indexes]
-            
-            if "vector_index" not in index_names:
-                # Create vector search index
-                index_definition = {
-                    "mappings": {
-                        "dynamic": True,
-                        "fields": {
-                            "embedding": {
-                                "dimensions": settings.VECTOR_DIMENSION,
-                                "similarity": "cosine",
-                                "type": "knnVector"
-                            }
-                        }
-                    }
-                }
-                
-                # Create the index
-                await self.db.command({
-                    "createIndexes": self.vector_collection.name,
-                    "indexes": [
-                        {
-                            "name": "vector_index",
-                            "key": {"embedding": "vector"},
-                            "weights": {"embedding": 1},
-                            "vectorSearchOptions": index_definition
-                        }
-                    ]
-                })
-                
-                # Create additional metadata indexes for filtering
-                await self.vector_collection.create_index([("metadata.source", ASCENDING)])
-                await self.vector_collection.create_index([("metadata.timestamp", ASCENDING)])
-                
-                logger.info("Vector search index created")
-            else:
-                logger.info("Vector search index already exists")
-                
-        except Exception as e:
-            logger.error(f"Error creating vector index: {str(e)}")
-            raise
-
-    async def close(self):
-        """
-        Close MongoDB connection.
-        """
-        if self.client:
-            self.client.close()
-            self.client = None
-            self.db = None
-            self.vector_collection = None
-            self.initialized = False
-            logger.info("MongoDB connection closed")
-
-# Create a singleton instance
-mongodb = MongoDB() 

src/ctp_slack_bot/db/__init__.py

@@ -0,0 +1 @@
+from ctp_slack_bot.db.mongo_db import MongoDB

src/ctp_slack_bot/db/mongo_db.py

@@ -0,0 +1,127 @@
+#from motor.motor_asyncio import AsyncIOMotorClient
+from loguru import logger
+from pydantic import BaseModel, model_validator
+#from pymongo import IndexModel, ASCENDING
+from typing import Optional, Self
+
+from ctp_slack_bot.core.config import Settings
+
+class MongoDB(BaseModel):
+    """
+    MongoDB connection and initialization class.
+    Handles connection to MongoDB, database selection, and index creation.
+    """
+
+    settings: Settings
+
+    @model_validator(mode='after')
+    def post_init(self: Self) -> Self:
+        logger.debug("Created {}", self.__class__.__name__)
+        return self
+
+    def __init__(self: Self, settings: Settings) -> Self:
+        #self.client: Optional[AsyncIOMotorClient] = None
+        #self.db = None
+        #self.vector_collection = None
+        #self.initialized = False
+        pass # The above initialization needs to be done some other way.
+
+    # async def connect(self):
+    #     """
+    #     Connect to MongoDB using connection string from settings.
+    #     """
+    #     if self.client is not None:
+    #         return
+
+    #     if not settings.MONGODB_URI:
+    #         raise ValueError("MONGODB_URI is not set in environment variables")
+
+    #     try:
+    #         # Create MongoDB connection
+    #         self.client = AsyncIOMotorClient(settings.MONGODB_URI.get_secret_value())
+    #         self.db = self.client[settings.MONGODB_DB_NAME]
+    #         self.vector_collection = self.db["vector_store"]
+    #         logger.info(f"Connected to MongoDB: {settings.MONGODB_DB_NAME}")
+    #     except Exception as e:
+    #         logger.error(f"Error connecting to MongoDB: {str(e)}")
+    #         raise
+
+    # async def initialize(self):
+    #     """
+    #     Initialize MongoDB with required collections and indexes.
+    #     """
+    #     if self.initialized:
+    #         return
+        
+    #     if not self.client:
+    #         await self.connect()
+        
+    #     try:
+    #         # Create vector index for similarity search
+    #         await self.create_vector_index()
+    #         self.initialized = True
+    #         logger.info("MongoDB initialized successfully")
+    #     except Exception as e:
+    #         logger.error(f"Error initializing MongoDB: {str(e)}")
+    #         raise
+
+    # async def create_vector_index(self):
+    #     """
+    #     Create vector index for similarity search using MongoDB Atlas Vector Search.
+    #     """
+    #     try:
+    #         # Check if index already exists
+    #         existing_indexes = await self.vector_collection.list_indexes().to_list(length=None)
+    #         index_names = [index.get('name') for index in existing_indexes]
+            
+    #         if "vector_index" not in index_names:
+    #             # Create vector search index
+    #             index_definition = {
+    #                 "mappings": {
+    #                     "dynamic": True,
+    #                     "fields": {
+    #                         "embedding": {
+    #                             "dimensions": settings.VECTOR_DIMENSION,
+    #                             "similarity": "cosine",
+    #                             "type": "knnVector"
+    #                         }
+    #                     }
+    #                 }
+    #             }
+                
+    #             # Create the index
+    #             await self.db.command({
+    #                 "createIndexes": self.vector_collection.name,
+    #                 "indexes": [
+    #                     {
+    #                         "name": "vector_index",
+    #                         "key": {"embedding": "vector"},
+    #                         "weights": {"embedding": 1},
+    #                         "vectorSearchOptions": index_definition
+    #                     }
+    #                 ]
+    #             })
+                
+    #             # Create additional metadata indexes for filtering
+    #             await self.vector_collection.create_index([("metadata.source", ASCENDING)])
+    #             await self.vector_collection.create_index([("metadata.timestamp", ASCENDING)])
+                
+    #             logger.info("Vector search index created")
+    #         else:
+    #             logger.info("Vector search index already exists")
+                
+    #     except Exception as e:
+    #         logger.error(f"Error creating vector index: {str(e)}")
+    #         raise
+
+    # async def close(self):
+    #     """
+    #     Close MongoDB connection.
+    #     """
+    #     if self.client:
+    #         self.client.close()
+    #         self.client = None
+    #         self.db = None
+    #         self.vector_collection = None
+    #         self.initialized = False
+    #         logger.info("MongoDB connection closed")

src/ctp_slack_bot/models/__init__.py

@@ -0,0 +1,4 @@
+from ctp_slack_bot.models.base import Content, Ingestible, Metadata
+from ctp_slack_bot.models.content import RetreivedContext
+from ctp_slack_bot.models.slack import SlackMessage
+from ctp_slack_bot.models.vector_query import VectorQuery

src/ctp_slack_bot/models/{VectorQuery.py → vector_query.py}

@@ -1,6 +1,5 @@
 from pydantic import BaseModel, Field, validator
 from typing import Optional, List, Dict, Any
-from ctp_slack_bot.core.config import settings
 
 class VectorQuery(BaseModel):
     """Model for vector database similarity search queries.
@@ -12,6 +11,6 @@ class VectorQuery(BaseModel):
         filter_metadata: Optional filters for metadata fields
     """
     query_text: str
-    k: int = Field(default=settings.TOP_K_MATCHES)
+    k: int
     score_threshold: float = Field(default=0.7)
-    filter_metadata: Optional[Dict[str, Any]] = None
+    filter_metadata: Optional[Dict[str, Any]] = None

src/ctp_slack_bot/services/__init__.py

@@ -0,0 +1,8 @@
+from ctp_slack_bot.services.answer_retrieval_service import AnswerRetrievalService
+from ctp_slack_bot.services.content_ingestion_service import ContentIngestionService
+from ctp_slack_bot.services.context_retrieval_service import ContextRetrievalService
+from ctp_slack_bot.services.event_brokerage_service import EventBrokerageService
+from ctp_slack_bot.services.question_dispatch_service import QuestionDispatchService
+from ctp_slack_bot.services.slack_service import SlackService
+from ctp_slack_bot.services.vector_database_service import VectorDatabaseService
+from ctp_slack_bot.services.vectorization_service import VectorizationService

src/ctp_slack_bot/services/{AnswerQuestionService.py → answer_retrieval_service.py}

@@ -1,17 +1,30 @@
-from pydantic import BaseModel, validator
-from typing import List, Optional, Tuple
-from ctp_slack_bot.core.config import settings
-import numpy as np
+# from asyncio import create_task
+from loguru import logger
 from openai import OpenAI
-from ctp_slack_bot.models.slack import SlackMessage
-from ctp_slack_bot.models.content import RetreivedContext
+from pydantic import BaseModel, model_validator
+from typing import List, Optional, Self, Tuple
 
-class GenerateAnswer():
+from ctp_slack_bot.core import Settings
+from ctp_slack_bot.models import RetreivedContext, SlackMessage
+from ctp_slack_bot.services.event_brokerage_service import EventBrokerageService
+
+
+class AnswerRetrievalService(BaseModel): # TODO: this should separate the OpenAI backend out into its own service.
     """
     Service for language model operations.
     """
-    def __init__(self):
-        self.client = OpenAI(api_key=settings.OPENAI_API_KEY)
+
+    settings: Settings
+    event_brokerage_service: EventBrokerageService
+    client: OpenAI # TODO: this should separate the OpenAI backend out into its own service, one that is agnostic.
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    @model_validator(mode='after')
+    def post_init(self: Self) -> Self:
+        logger.debug("Created {}", self.__class__.__name__)
+        return self
 
     def generate_answer(self, question: SlackMessage, context: List[RetreivedContext]) -> str:
             """Generate a response using OpenAI's API with retrieved context.
@@ -50,11 +63,3 @@ class GenerateAnswer():
             )
             
             return response.choices[0].message.content
-
-
-
-### REMOVE BELOW, PUT SOMEWHERE IN TESTS BUT IDK WHERE YET
-# sm = SlackMessage(text="What is the capital of France?", channel_id="123", user_id="456", timestamp="789")
-# context = [RetreivedContext(contextual_text="The capital of France is Paris", metadata_source="class materials", similarity_score=0.95)]
-# a = GenerateAnswer()
-# a.generate_answer(sm, context)

src/ctp_slack_bot/services/content_ingestion_service.py

@@ -0,0 +1,21 @@
+from loguru import logger
+from pydantic import BaseModel, model_validator
+from typing import Self
+
+from ctp_slack_bot.core import Settings
+from ctp_slack_bot.services.vector_database_service import VectorDatabaseService
+from ctp_slack_bot.services.vectorization_service import VectorizationService
+
+class ContentIngestionService(BaseModel):
+    """
+    Service for ingesting content.
+    """
+
+    settings: Settings
+    vector_database_service: VectorDatabaseService
+    vectorization_service: VectorizationService
+
+    @model_validator(mode='after')
+    def post_init(self: Self) -> Self:
+        logger.debug("Created {}", self.__class__.__name__)
+        return self

src/ctp_slack_bot/services/{ContextRetrievalService.py → context_retrieval_service.py}

@@ -1,29 +1,31 @@
-import logging
-from typing import List, Dict, Any, Optional
+from loguru import logger
+from pydantic import BaseModel, model_validator
+from typing import Any, Dict, List, Optional, Self
 
-from ctp_slack_bot.models.slack import SlackMessage
-from ctp_slack_bot.models.content import RetreivedContext
-from ctp_slack_bot.models.VectorQuery import VectorQuery
-from ctp_slack_bot.services.VectorizationService import VectorizationService
-from ctp_slack_bot.services.VectorDatabaseService import VectorDatabaseService
-from ctp_slack_bot.core.config import settings
+from ctp_slack_bot.core.config import Settings
+from ctp_slack_bot.models import RetreivedContext, SlackMessage, VectorQuery
+from ctp_slack_bot.services.vector_database_service import VectorDatabaseService
+from ctp_slack_bot.services.vectorization_service import VectorizationService
 
-logger = logging.getLogger(__name__)
-
-class ContextRetrievalService:
+class ContextRetrievalService(BaseModel):
     """
     Service for retrieving relevant context from the vector database based on user questions.
     """
-    
-    def __init__(self):
-        self.vectorization_service = VectorizationService()
-        self.vector_db_service = VectorDatabaseService()
+
+    settings: Settings
+    vectorization_service: VectorizationService
+    vector_database_service: VectorDatabaseService
+
+    @model_validator(mode='after')
+    def post_init(self: Self) -> Self:
+        logger.debug("Created {}", self.__class__.__name__)
+        return self
     
     async def initialize(self):
         """
         Initialize the required services.
         """
-        await self.vector_db_service.initialize()
+        await self.vector_database_service.initialize()
     
     async def get_context(self, message: SlackMessage) -> List[RetreivedContext]:
         """
@@ -62,7 +64,7 @@ class ContextRetrievalService:
             )
             
             # Search for similar content in vector database
-            context_results = await self.vector_db_service.search_by_similarity(
+            context_results = await self.vector_database_service.search_by_similarity(
                 query=vector_query,
                 query_embedding=query_embedding
             )

src/ctp_slack_bot/services/event_brokerage_service.py

@@ -0,0 +1,38 @@
+# from asyncio import create_task
+from loguru import logger
+from openai import OpenAI
+from pydantic import BaseModel, model_validator
+from typing import Any, Callable, Dict, List, Self
+
+from ctp_slack_bot.core import Settings
+from ctp_slack_bot.models import RetreivedContext, SlackMessage
+from ctp_slack_bot.services.content_ingestion_service import ContentIngestionService
+from ctp_slack_bot.services.context_retrieval_service import ContextRetrievalService
+
+
+class EventBrokerageService(BaseModel):
+    """
+    Service for brokering events between services.
+    """
+
+    subscribers: Dict[str, List[Callable]] = {}
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    @model_validator(mode='after')
+    def post_init(self: Self) -> Self:
+        logger.debug("Created {}", self.__class__.__name__)
+        return self
+
+    def subscribe(self: Self, event_type: str, callback: Callable) -> None:
+        """Subscribe to an event type with a callback function."""
+        if event_type not in self.subscribers:
+            self.subscribers[event_type] = []
+        self.subscribers[event_type].append(callback)
+    
+    def publish(self: Self, event_type: str, data: Any = None) -> None:
+        """Publish an event with optional data to all subscribers."""
+        if event_type in self.subscribers:
+            for callback in self.subscribers[event_type]:
+                callback(data)

src/ctp_slack_bot/services/question_dispatch_service.py

@@ -0,0 +1,31 @@
+# from asyncio import create_task
+from loguru import logger
+from openai import OpenAI
+from pydantic import BaseModel, model_validator
+from typing import List, Optional, Self, Tuple
+
+from ctp_slack_bot.core import Settings
+from ctp_slack_bot.models import RetreivedContext, SlackMessage
+from ctp_slack_bot.services.answer_retrieval_service import AnswerRetrievalService
+from ctp_slack_bot.services.context_retrieval_service import ContextRetrievalService
+from ctp_slack_bot.services.event_brokerage_service import EventBrokerageService
+
+
+class QuestionDispatchService(BaseModel):
+    """
+    Service for determining whether a Slack message constitutes a question.
+    """
+
+    settings: Settings
+    event_brokerage_service: EventBrokerageService
+    context_retrieval_service: ContextRetrievalService
+    answer_retrieval_service: AnswerRetrievalService
+
+    @model_validator(mode='after')
+    def post_init(self: Self) -> Self:
+        logger.debug("Created {}", self.__class__.__name__)
+        return self
+
+    def push(self: Self, message: SlackMessage) -> None:
+        context = self.context_retrieval_service.get_context(message)
+        self.answer_retrieval_service.generate_answer(message, context)

src/ctp_slack_bot/services/slack_service.py

@@ -0,0 +1,23 @@
+# from asyncio import create_task
+from loguru import logger
+from openai import OpenAI
+from pydantic import BaseModel, model_validator
+from typing import List, Optional, Self, Tuple
+
+from ctp_slack_bot.core import Settings
+from ctp_slack_bot.models import RetreivedContext, SlackMessage
+from ctp_slack_bot.services.event_brokerage_service import EventBrokerageService
+
+
+class SlackService(BaseModel):
+    """
+    Service for interfacing with Slack.
+    """
+
+    settings: Settings
+    event_brokerage_service: EventBrokerageService
+
+    @model_validator(mode='after')
+    def post_init(self: Self) -> Self:
+        logger.debug("Created {}", self.__class__.__name__)
+        return self

src/ctp_slack_bot/services/{VectorDatabaseService.py → vector_database_service.py}

@@ -1,18 +1,24 @@
-import logging
-from typing import List, Dict, Any, Optional
-# import numpy as np
+from loguru import logger
+from pydantic import BaseModel, model_validator
+from typing import Any, Dict, List, Optional, Self
 
-from ctp_slack_bot.db.MongoDB import mongodb
-from ctp_slack_bot.models.VectorQuery import VectorQuery
-from ctp_slack_bot.models.content import RetreivedContext
+from ctp_slack_bot.core import Settings
+from ctp_slack_bot.db import MongoDB
+from ctp_slack_bot.models import VectorQuery, RetreivedContext
 
-logger = logging.getLogger(__name__)
-
-class VectorDatabaseService:
+class VectorDatabaseService(BaseModel): # TODO: this should not rely specifically on MongoDB.
     """
     Service for storing and retrieving vector embeddings from MongoDB.
     """
-    
+
+    settings: Settings
+    mongo_db: MongoDB
+
+    @model_validator(mode='after')
+    def post_init(self: Self) -> Self:
+        logger.debug("Created {}", self.__class__.__name__)
+        return self
+
     async def initialize(self):
         """
         Initialize the database connection.

src/ctp_slack_bot/services/{VectorizationService.py → vectorization_service.py}

@@ -1,17 +1,26 @@
-from pydantic import BaseModel, validator
-from typing import List, Optional
-from ctp_slack_bot.core.config import settings
+from loguru import logger
 import numpy as np
 from openai import OpenAI
+from pydantic import BaseModel, model_validator
+from typing import List, Optional, Self
 
+from ctp_slack_bot.core import Settings
 
-class VectorizationService():
+class VectorizationService(BaseModel):
     """
     Service for vectorizing chunks of text data.
     """
-    def __init__(self):
-        self.client = OpenAI(api_key=settings.OPENAI_API_KEY)
 
+    settings: Settings
+    client: OpenAI # TODO: this should separate the OpenAI backend out into its own service, one that is agnostic.
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    @model_validator(mode='after')
+    def post_init(self: Self) -> Self:
+        logger.debug("Created {}", self.__class__.__name__)
+        return self
         
     def get_embeddings(self, texts: List[str]) -> np.ndarray:
         """Get embeddings for a list of texts using OpenAI's API.
@@ -28,7 +37,7 @@ class VectorizationService():
         try:
             # Use the initialized client instead of the global openai module
             response = self.client.embeddings.create(
-                model=settings.EMBEDDING_MODEL,
+                model=self.settings.EMBEDDING_MODEL,
                 input=texts,
                 encoding_format="float"  # Ensure we get raw float values
             )
@@ -36,9 +45,9 @@ class VectorizationService():
             # Extract embeddings and verify dimensions
             embeddings = np.array([data.embedding for data in response.data])
             
-            if embeddings.shape[1] != settings.VECTOR_DIMENSION:
+            if embeddings.shape[1] != self.settings.VECTOR_DIMENSION:
                 raise ValueError(
-                    f"Embedding dimension mismatch. Expected {settings.VECTOR_DIMENSION}, "
+                    f"Embedding dimension mismatch. Expected {self.settings.VECTOR_DIMENSION}, "
                     f"but got {embeddings.shape[1]}. Please update VECTOR_DIMENSION "
                     f"in config.py to match the model's output."
                 )

src/ctp_slack_bot/tasks/__init__.py

@@ -0,0 +1 @@
+from ctp_slack_bot.tasks.scheduler import start_scheduler, stop_scheduler

src/ctp_slack_bot/tasks/scheduler.py

@@ -6,9 +6,7 @@ from loguru import logger
 from pytz import timezone
 from typing import Optional
 
-from ctp_slack_bot.containers import Container
-#from ctp_slack_bot.tasks.error_report import send_error_report
-#from ctp_slack_bot.tasks.transcript_cleanup import cleanup_old_transcripts
+from ctp_slack_bot import Container
 
 @inject
 def start_scheduler(container: Container) -> AsyncIOScheduler: