W.I.P.

pyproject.toml

@@ -33,7 +33,6 @@ dependencies = [
     "apscheduler>=3.11.0",
     "slack-sdk>=3.35.0",
     "pymongo>=4.11.3 ",
-    "numpy>=2.2.4",
     "webvtt-py>=0.5.1",
     "openai>=1.70.0",
 #    "langchain>=0.3.23",

src/ctp_slack_bot/__init__.py

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

src/ctp_slack_bot/api/main.py

@@ -1,12 +1,19 @@
 from contextlib import asynccontextmanager
+from dependency_injector.wiring import inject, Provide
 from fastapi import FastAPI, HTTPException, Depends
 from loguru import logger
-from typing import AsyncGenerator
-from dependency_injector.wiring import inject, Provide
+from typing import Any, AsyncGenerator
+from slack_bolt import App
+from slack_bolt.adapter.socket_mode import SocketModeHandler
+from starlette.requests import Request
+from starlette.responses import Response
+from threading import Thread
+from typing import Any, Dict, Self
 
-from ctp_slack_bot import Container
+from ctp_slack_bot.containers import Container
 from ctp_slack_bot.api.routes import router
-from ctp_slack_bot.core import Settings, setup_logging
+from ctp_slack_bot.core.config import Settings
+from ctp_slack_bot.core.logging import setup_logging
 from ctp_slack_bot.core.response_rendering import PrettyJSONResponse
 from ctp_slack_bot.tasks import start_scheduler, stop_scheduler
 
@@ -16,6 +23,7 @@ async def lifespan(app: FastAPI) -> AsyncGenerator:
     Lifespan context manager for FastAPI application.
     Handles startup and shutdown events.
     """
+
     # Initialize container and wire the container to modules that need dependency injection.
     container = Container()
     container.wire(packages=['ctp_slack_bot'])
@@ -25,10 +33,38 @@ async def lifespan(app: FastAPI) -> AsyncGenerator:
     setup_logging(container)
     logger.info("Starting application")
 
+    # Log route being served.
+    logger.info("Serving {} route(s):{}", len(app.routes), ''.join(f"\n* {", ".join(route.methods)} {route.path}" for route in app.routes))
+
     # Start the scheduler.
     scheduler = start_scheduler(container)
     logger.info("Started scheduler")
 
+    # Initialize primordial dependencies in container.
+    container.primordial_services()
+
+    # Start Slack socket mode in a background thread and set up an event handler for the Bolt app.
+    bolt_app = container.slack_bolt_app()
+    slack_service = container.slack_service()
+    @bolt_app.event("message")
+    def handle_message(body: Dict[str, Any]) -> None:
+        logger.debug("Received Slack message event: {}", body)
+        slack_service.process_message(body)
+    @bolt_app.event("app_mention")
+    def handle_message(body: Dict[str, Any]) -> None:
+        logger.debug("Received Slack app mention event: {}", body)
+        slack_service.process_message(body)
+
+    # Start Socket Mode handler in a background thread
+    socket_mode_handler = SocketModeHandler(
+        app=bolt_app,
+        app_token=container.settings().SLACK_APP_TOKEN.get_secret_value()
+    )
+    socket_thread = Thread(target=socket_mode_handler.start)
+    socket_thread.daemon = True
+    socket_thread.start()
+    logger.info("Started Slack Socket Mode handler")
+
     yield # control to FastAPI until shutdown.
 
     # Shutdown.
@@ -36,7 +72,6 @@ async def lifespan(app: FastAPI) -> AsyncGenerator:
     stop_scheduler(scheduler)
     logger.info("Stopped scheduler")
 
-
 app = FastAPI(
     title="CTP Slack Bot",
     description="A Slack bot for processing and analyzing Zoom transcripts using AI",

src/ctp_slack_bot/api/routes.py

@@ -2,9 +2,9 @@ from fastapi import APIRouter, Depends, HTTPException, status
 from dependency_injector.wiring import inject, Provide
 from loguru import logger
 
-from ctp_slack_bot import Container
-from ctp_slack_bot.core import Settings
-from ctp_slack_bot.services import SlackService
+from ctp_slack_bot.containers import Container
+from ctp_slack_bot.core.config import Settings
+from ctp_slack_bot.services import AnswerRetrievalService, ContentIngestionService, ContextRetrievalService, EmbeddingsModelService, LanguageModelService, QuestionDispatchService, SlackService, VectorDatabaseService, VectorizationService
 
 router = APIRouter(prefix="/api/v1")
 
@@ -15,6 +15,51 @@ async def get_env(settings: Settings = Depends(Provide[Container.settings])) ->
         raise HTTPException(status_code=404)
     return settings
 
+@router.get("/answer_retrieval_service")
+@inject
+async def test(answer_retrieval_service: AnswerRetrievalService = Depends(Provide[Container.answer_retrieval_service])) -> None:
+    pass
+
+@router.get("/content_ingestion_service")
+@inject
+async def test(content_ingestion_service: ContentIngestionService = Depends(Provide[Container.content_ingestion_service])) -> None:
+    pass
+
+@router.get("/context_retrieval_service")
+@inject
+async def test(context_retrieval_service: ContextRetrievalService = Depends(Provide[Container.context_retrieval_service])) -> None:
+    pass
+
+@router.get("/embeddings_model_service")
+@inject
+async def test(embeddings_model_service: EmbeddingsModelService = Depends(Provide[Container.embeddings_model_service])) -> None:
+    pass
+
+@router.get("/language_model_service")
+@inject
+async def test(language_model_service: LanguageModelService = Depends(Provide[Container.language_model_service])) -> None:
+    pass
+
+@router.get("/question_dispatch_service")
+@inject
+async def test(question_dispatch_service: QuestionDispatchService = Depends(Provide[Container.question_dispatch_service])) -> None:
+    pass
+
+@router.get("/slack_service")
+@inject
+async def test(slack_service: SlackService = Depends(Provide[Container.slack_service])) -> None:
+    pass
+
+@router.get("/vector_database_service")
+@inject
+async def test(vector_database_service: VectorDatabaseService = Depends(Provide[Container.vector_database_service])) -> None:
+    pass
+
+@router.get("/vectorization_service")
+@inject
+async def test(vectorization_service: VectorizationService = Depends(Provide[Container.vectorization_service])) -> None:
+    pass
+
 # @router.post("/transcripts/analyze", response_model=TranscriptResponse)
 # async def analyze_transcript(
 #     request: TranscriptRequest,

src/ctp_slack_bot/containers.py

@@ -1,13 +1,16 @@
 from dependency_injector.containers import DeclarativeContainer
-from dependency_injector.providers import Factory, Singleton
-from openai import OpenAI
+from dependency_injector.providers import Factory, List, Singleton
+from slack_bolt import App
+from slack_bolt.adapter.socket_mode import SocketModeHandler
 
 from ctp_slack_bot.core.config import Settings
 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.embeddings_model_service import EmbeddingsModelService
 from ctp_slack_bot.services.event_brokerage_service import EventBrokerageService
+from ctp_slack_bot.services.language_model_service import LanguageModelService
 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
@@ -16,29 +19,21 @@ from ctp_slack_bot.services.vectorization_service import VectorizationService
 
 class Container(DeclarativeContainer):
     settings = Singleton(Settings)
-
     event_brokerage_service = Singleton(EventBrokerageService)
-
-    mongo_db = Singleton(MongoDB, settings=settings)
-
+    slack_bolt_app = Factory(App, token=settings.provided.SLACK_BOT_TOKEN().get_secret_value())
+    mongo_db = Singleton(MongoDB, settings=settings) # TODO: we could really use less commitment to MongoDB.
     # Repositories
     # transcript_repository = Factory(
     #     # Your transcript repository class
-    #     db=db
+    #     mongo_db=mongo_db
     # )
-
-    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)
-
+    embeddings_model_service = Singleton(EmbeddingsModelService, settings=settings)
+    vectorization_service = Singleton(VectorizationService, settings=settings, embeddings_model_service=embeddings_model_service)
     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)
-
+    language_model_service = Singleton(LanguageModelService, settings=settings)
+    answer_retrieval_service = Singleton(AnswerRetrievalService, settings=settings, event_brokerage_service=event_brokerage_service, language_model_service=language_model_service)
     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)
-
-    slack_service = Singleton(SlackService, settings=settings, event_brokerage_service=event_brokerage_service)
+    slack_service = Singleton(SlackService, event_brokerage_service=event_brokerage_service, slack_bolt_app=slack_bolt_app)
+    primordial_services = List(settings, event_brokerage_service, slack_bolt_app, slack_service, question_dispatch_service, content_ingestion_service)

src/ctp_slack_bot/core/__init__.py

@@ -1,2 +1 @@
 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

@@ -1,7 +1,10 @@
+from dependency_injector.wiring import Provide
 from logging import __file__ as logging_file, basicConfig, currentframe, getLogger, Handler, INFO, LogRecord
 from loguru import logger
 from sys import stderr
-from typing import Dict, Union
+from typing import Self
+
+from ctp_slack_bot.containers import Container
 
 class InterceptHandler(Handler):
     """
@@ -11,7 +14,7 @@ class InterceptHandler(Handler):
     to Loguru, allowing unified logging across the application.
     """
     
-    def emit(self, record: LogRecord) -> None:
+    def emit(self: Self, record: LogRecord) -> None:
         # Get corresponding Loguru level if it exists
         try:
             level = logger.level(record.levelname).name
@@ -29,7 +32,7 @@ class InterceptHandler(Handler):
         )
 
 
-def setup_logging(container: "Container") -> None:
+def setup_logging(container: "Container") -> None: # TODO: Perhaps get rid of the container dependence since we only need two settings.
     """
     Configure logging with Loguru.
     
@@ -37,7 +40,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
+    from ctp_slack_bot.containers import Container
     settings = container.settings() if container else Provide[Container.settings]
 
     # Remove default loguru handler

src/ctp_slack_bot/core/response_rendering.py

@@ -10,4 +10,4 @@ class PrettyJSONResponse(JSONResponse):
             allow_nan=False,
             indent=4,
             separators=(", ", ": "),
-        ).encode("utf-8")
+        ).encode()

src/ctp_slack_bot/db/mongo_db.py

@@ -1,6 +1,6 @@
 #from motor.motor_asyncio import AsyncIOMotorClient
 from loguru import logger
-from pydantic import BaseModel, model_validator
+from pydantic import BaseModel, model_validator, PrivateAttr
 #from pymongo import IndexModel, ASCENDING
 from typing import Optional, Self
 
@@ -13,19 +13,23 @@ class MongoDB(BaseModel):
     """
 
     settings: Settings
+    _client: PrivateAttr = PrivateAttr()
+    _db: PrivateAttr = PrivateAttr()
+    _vector_collection: PrivateAttr = PrivateAttr()
+    _initialized: PrivateAttr = PrivateAttr()
+
+    def __init__(self: Self, **data) -> None:
+        super().__init__(**data)
+        self._client = None
+        self._db = None
+        self._vector_collection = None
+        self._initialized = False
 
     @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.

src/ctp_slack_bot/enums.py

@@ -0,0 +1,6 @@
+from enum import auto, StrEnum
+
+class EventType(StrEnum):
+    INCOMING_CONTENT = auto()
+    INCOMING_SLACK_MESSAGE = auto()
+    OUTGOING_SLACK_RESPONSE = auto()

src/ctp_slack_bot/models/__init__.py

@@ -1,4 +1,3 @@
-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.base import Chunk, Content, VectorizedChunk
+from ctp_slack_bot.models.slack import SlackEventPayload, SlackMessage, SlackReaction, SlackResponse, SlackUserTimestampPair
 from ctp_slack_bot.models.vector_query import VectorQuery

src/ctp_slack_bot/models/base.py

@@ -1,61 +1,52 @@
 from abc import ABC, abstractmethod
-from datetime import datetime
-from pydantic import BaseModel, Field, validator
-from typing import Dict, List, Optional, Union, Any, ClassVar
-import hashlib
-import json
+from pydantic import BaseModel, ConfigDict
+from typing import Any, Dict, final, Self, Sequence
 
 
-class Metadata(BaseModel):
-    """A class representing metadata about content."""
+class Chunk(BaseModel):
+    """A class representing a chunk of content."""
 
-    id: str                     # The content’s identity consistent across modifications
-    modification_time: datetime # The content’s modification for detection of alterations
-    hash: str                   # The content’s hash for detection of alterations
+    text: str                   # The text representation
+    parent_id: str              # The source content’s identity
+    chunk_id: str               # This chunk’s identity—unique within the source content
+    metadata: Dict[str, Any]
 
+    model_config = ConfigDict(frozen=True)
 
-class Content(BaseModel):
-    """A class representing ingested content."""
 
-    metadata: Metadata
+@final
+class VectorizedChunk(Chunk):
+    """A class representing a vectorized chunk of content."""
 
+    embedding: Sequence[float]  # The vector representation
 
+    model_config = ConfigDict(frozen=True)
 
-class Ingestible(ABC, BaseModel):
-    """An abstract base class for ingestible content."""
 
-    metadata: Metadata
+class Content(ABC, BaseModel):
+    """An abstract base class for all types of content."""
+
+    model_config = ConfigDict(frozen=True)
+
+    @abstractmethod
+    def get_chunks(self: Self) -> Sequence[Chunk]:
+        pass
+
+    @abstractmethod
+    def get_metadata(self: Self) -> Dict[str, Any]:
+        pass
 
     @property
     @abstractmethod
-    def content(self) -> Content:
-        """
-        Return content ready for vectorization.
-        
-        This could be:
-        - A single string
-        - A list of strings (pre-chunked)
-        - A more complex structure that can be recursively processed
-        """
+    def get_text(self: Self) -> str:
         pass
-    
-    def get_chunks(self) -> List[str]:
-        """
-        Split content into chunks suitable for vectorization.
-        Override this in subclasses for specialized chunking logic.
-        """
-        content = self.content
-        if isinstance(content, str):
-            # Simple chunking by character count
-            return [content[i:i+self.chunk_size] 
-                   for i in range(0, len(content), self.chunk_size)]
-        elif isinstance(content, list):
-            # Content is already chunked
-            return content
-        else:
-            raise ValueError(f"Unsupported content type: {type(content)}")
-    
+
     @property
-    def key(self) -> str:
-        """Convenience accessor for the metadata key."""
-        return self.metadata.key
+    @abstractmethod
+    def bytes(self: Self) -> bytes:
+        pass
+
+    @property
+    @abstractmethod
+    def id(self: Self) -> str:
+        pass

src/ctp_slack_bot/models/content.py

@@ -1,19 +0,0 @@
-from pydantic import BaseModel, Field
-from typing import Optional, List, Dict, Any
-from ctp_slack_bot.models.slack import SlackMessage
-
-class RetreivedContext(BaseModel):
-    """Represents a the context of a question from Slack returned from the Vector Store Database.
-    
-    contextual_text: The text that is relevant to the question.
-    metadata_source: The source of the contextual text.
-    similarity_score: The similarity score of the contextual text to the question.
-
-    in_reation_to_question: OPTINAL:  The question that the contextual text is related to.
-    """
-    contextual_text: str
-    metadata_source: str
-    similarity_score: float
-    
-    said_by: str = Optional[None]
-    in_reation_to_question: str = Optional[None]

src/ctp_slack_bot/models/slack.py

@@ -1,16 +1,96 @@
-from pydantic import BaseModel, Field
-from typing import Optional, List, Dict, Any
+from datetime import datetime
+from json import dumps
+from pydantic import BaseModel, ConfigDict, PositiveInt, PrivateAttr
+from typing import Any, Dict, Literal, Optional, Self, Sequence
 
-class SlackMessage(BaseModel):
+from ctp_slack_bot.models.base import Chunk, Content
+
+class SlackEventPayload(BaseModel):
+    """Represents a general event payload from Slack."""
+    type: str
+    event_ts: str
+
+    model_config = ConfigDict(extra='allow', frozen=True)
+
+class SlackEvent(BaseModel):
+    """Represents a general event from Slack."""
+
+    token: str
+    team_id: str
+    api_app_id: str
+    event: SlackEventPayload
+    type: str
+    event_id: str
+    event_time: int
+    authed_users: Sequence[str]
+
+    model_config = ConfigDict(frozen=True) 
+
+class SlackUserTimestampPair(BaseModel):
+    """Represents a Slack user-timestamp pair."""
+
+    user: str
+    ts: str
+
+    model_config = ConfigDict(frozen=True)
+
+class SlackReaction(BaseModel):
+    """Represents a Slack reaction information."""
+
+    name: str
+    count: PositiveInt
+    users: Sequence[str]
+
+    model_config = ConfigDict(frozen=True)
+
+class SlackMessage(Content):
     """Represents a message from Slack after adaptation."""
-    channel_id: str
-    user_id: str
-    text: str
+
+    type: Literal["app_mention", "message"]
+    subtype: Optional[str] = None
+    channel: str
+    channel_type: Optional[str] = None
+    user: Optional[str] = None
+    bot_id: Optional[str] = None
     thread_ts: Optional[str] = None
-    timestamp: str
-    is_question: bool = False
-    
+    text: str
+    ts: str
+    edited: Optional[SlackUserTimestampPair] = None
+    event_ts: str
+    deleted_ts: Optional[str] = None
+    hidden: bool = False
+    is_starred: Optional[bool] = None
+    pinned_to: Optional[Sequence[str]] = None
+    reactions: Optional[Sequence[SlackReaction]] = None
+    _canonical_json: PrivateAttr
+
+    def __init__(self: Self, **data: Dict[str, Any]) -> None:
+        super().__init__(**data)
+        self._canonical_json = PrivateAttr(default_factory=lambda: dumps(data, sort_keys=True).encode())
+
+    def get_chunks(self: Self) -> Sequence[Chunk]:
+        return (Chunk(text=self.text, parent_id=self.id, chunk_id="", metadata=self.metadata), )
+
+    def get_metadata(self: Self) -> Dict[str, Any]:
+        return {
+            "modificationTime": datetime.fromtimestamp(float(self.ts))
+        }
+
+    def get_text(self: Self) -> str:
+        return self.text
+
     @property
-    def key(self) -> str:
+    def bytes(self: Self) -> bytes:
+        return self._canonical_json
+
+    @property
+    def id(self: Self) -> str:
         """Unique identifier for this message."""
-        return f"slack:{self.channel_id}:{self.timestamp}"
+        return f"slack-message:{self.channel}:{self.ts}"
+
+class SlackResponse(BaseModel): # TODO: This should also be based on Content as it is a SlackMessage―just not one for which we know the identity yet.
+    """Represents a response message to be sent to Slack."""
+
+    text: str
+    channel: Optional[str]
+    thread_ts: Optional[str] = None

src/ctp_slack_bot/models/vector_query.py

@@ -1,5 +1,5 @@
-from pydantic import BaseModel, Field, validator
-from typing import Optional, List, Dict, Any
+from pydantic import BaseModel, Field, model_validator
+from typing import Any, Dict, Optional, Sequence
 
 class VectorQuery(BaseModel):
     """Model for vector database similarity search queries.
@@ -10,7 +10,8 @@ class VectorQuery(BaseModel):
         score_threshold: Minimum similarity score threshold for inclusion in results
         filter_metadata: Optional filters for metadata fields
     """
-    query_text: str
+
+    query_embeddings: Sequence[float]
     k: int
     score_threshold: float = Field(default=0.7)
     filter_metadata: Optional[Dict[str, Any]] = None

src/ctp_slack_bot/services/__init__.py

@@ -1,7 +1,9 @@
 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.embeddings_model_service import EmbeddingsModelService
 from ctp_slack_bot.services.event_brokerage_service import EventBrokerageService
+from ctp_slack_bot.services.language_model_service import LanguageModelService
 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

src/ctp_slack_bot/services/answer_retrieval_service.py

@@ -1,65 +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 typing import Collection, Self
 
 from ctp_slack_bot.core import Settings
-from ctp_slack_bot.models import RetreivedContext, SlackMessage
+from ctp_slack_bot.enums import EventType
+from ctp_slack_bot.models import Chunk, SlackMessage, SlackResponse
 from ctp_slack_bot.services.event_brokerage_service import EventBrokerageService
+from ctp_slack_bot.services.language_model_service import LanguageModelService
 
 
-class AnswerRetrievalService(BaseModel): # TODO: this should separate the OpenAI backend out into its own service.
+class AnswerRetrievalService(BaseModel):
     """
-    Service for language model operations.
+    Service for context-based answer retrievel from a language model.
     """
 
     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
+    language_model_service: LanguageModelService
 
     @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.
-            
-            Args:
-                question (str): The user's question
-                context (List[RetreivedContext]): List of RetreivedContext 
-                
-            Returns:
-                str: Generated answer
-            """
-            # Prepare context string from retrieved chunks
-            context_str = ""
-            for c in context:
-                context_str += f"{c.contextual_text}\n"
-
-            
-            # logger.info(f"Generating response for question: {question}")
-            # logger.info(f"Using {len(context)} context chunks")
-            
-            # Create messages for the chat completion
-            messages = [
-                {"role": "system", "content": settings.SYSTEM_PROMPT},
-                {"role": "user", "content": 
-                    f"""Student Auestion: {question.text}
-                    Context from class materials and transcripts: {context_str}              
-                    Please answer the Student Auestion based on the Context from class materials and transcripts. If the context doesn't contain relevant information, acknowledge that and suggest asking the professor."""}
-            ]
-            
-            # Generate response
-            response = self.client.chat.completions.create(
-                model=settings.CHAT_MODEL,
-                messages=messages,
-                max_tokens=settings.MAX_TOKENS,
-                temperature=settings.TEMPERATURE
-            )
-            
-            return response.choices[0].message.content
+    def push(self: Self, question: SlackMessage, context: Collection[Chunk]) -> None:
+        channel_to_respond_to = question.channel
+        thread_to_respond_to = question.thread_ts if question.thread_ts else question.ts
+        answer = self.language_model_service.answer_question(question.text, context)
+        slack_response = SlackResponse(text=answer, channel=channel_to_respond_to, thread_ts=thread_to_respond_to)
+        self.event_brokerage_service.publish(EventType.OUTGOING_SLACK_RESPONSE, slack_response)

src/ctp_slack_bot/services/content_ingestion_service.py

@@ -1,8 +1,11 @@
 from loguru import logger
 from pydantic import BaseModel, model_validator
-from typing import Self
+from typing import Self, Sequence
 
 from ctp_slack_bot.core import Settings
+from ctp_slack_bot.enums import EventType
+from ctp_slack_bot.models import Chunk, Content, SlackMessage
+from ctp_slack_bot.services.event_brokerage_service import EventBrokerageService
 from ctp_slack_bot.services.vector_database_service import VectorDatabaseService
 from ctp_slack_bot.services.vectorization_service import VectorizationService
 
@@ -12,10 +15,33 @@ class ContentIngestionService(BaseModel):
     """
 
     settings: Settings
+    event_brokerage_service: EventBrokerageService
     vector_database_service: VectorDatabaseService
     vectorization_service: VectorizationService
 
     @model_validator(mode='after')
     def post_init(self: Self) -> Self:
         logger.debug("Created {}", self.__class__.__name__)
+        self.event_brokerage_service.subscribe(EventType.INCOMING_CONTENT, self.process_incoming_content)
+        self.event_brokerage_service.subscribe(EventType.INCOMING_SLACK_MESSAGE, self.process_incoming_slack_message)
         return self
+
+    def process_incoming_content(self: Self, content: Content) -> None:
+        logger.debug("Content ingestion service received content with metadata: {}", content.get_metadata())
+        # if self.vector_database_service.has_content(content.id) # TODO
+        #    logger.debug("Ignored content with ID {} because it already exists in the database.", content.id)
+        #    return
+        chunks = content.get_chunks()
+        self.__vectorize_and_store_chunks_in_database(chunks)
+        logger.debug("Stored {} vectorized chunk(s) in the database.", len(chunks))
+
+    def process_incoming_slack_message(self: Self, slack_message: SlackMessage) -> None:
+        logger.debug("Content ingestion service received a Slack message: {}", slack_message.text)
+        chunks = slack_message.get_chunks()
+        self.__vectorize_and_store_chunks_in_database(chunks)
+        logger.debug("Stored {} vectorized chunk(s) in the database.", len(chunks))
+
+    def __vectorize_and_store_chunks_in_database(self: Self, chunks: Sequence[Chunk]) -> None:
+        # vectorized_chunks = self.vectorization_service.vectorize(chunks) # TODO
+        # self.vector_database_service.store(vectorized_chunks) # TODO
+        pass

src/ctp_slack_bot/services/context_retrieval_service.py

@@ -1,9 +1,9 @@
 from loguru import logger
 from pydantic import BaseModel, model_validator
-from typing import Any, Dict, List, Optional, Self
+from typing import Self, Sequence
 
 from ctp_slack_bot.core.config import Settings
-from ctp_slack_bot.models import RetreivedContext, SlackMessage, VectorQuery
+from ctp_slack_bot.models import Chunk, SlackMessage, VectorQuery, VectorizedChunk
 from ctp_slack_bot.services.vector_database_service import VectorDatabaseService
 from ctp_slack_bot.services.vectorization_service import VectorizationService
 
@@ -20,14 +20,15 @@ class ContextRetrievalService(BaseModel):
     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_database_service.initialize()
-    
-    async def get_context(self, message: SlackMessage) -> List[RetreivedContext]:
+
+    # Should not allow initialization calls to bubble up all the way to the surface ― sequester in `post_init` or the class on which it depends.
+    # async def initialize(self):
+    #     """
+    #     Initialize the required services.
+    #     """
+    #     await self.vector_database_service.initialize()
+
+    def get_context(self, message: SlackMessage) -> Sequence[Chunk]:
         """
         Retrieve relevant context for a given Slack message.
         
@@ -43,36 +44,37 @@ class ContextRetrievalService(BaseModel):
         Returns:
             List[RetreivedContext]: List of retrieved context items with similarity scores
         """
-        if not message.is_question:
-            logger.debug(f"Message {message.key} is not a question, skipping context retrieval")
-            return []
+        # if not message.is_question:
+        #     logger.debug(f"Message {message.key} is not a question, skipping context retrieval")
+        #     return []
         
-        try:
-            # Vectorize the message text
-            embeddings = self.vectorization_service.get_embeddings([message.text])
-            if embeddings is None or len(embeddings) == 0:
-                logger.error(f"Failed to generate embedding for message: {message.key}")
-                return []
+        # try:
+        #     # Vectorize the message text
+        #     embeddings = self.vectorization_service.vectorize([message.text])
+        #     if embeddings is None or len(embeddings) == 0:
+        #         logger.error(f"Failed to generate embedding for message: {message.key}")
+        #         return []
             
-            query_embedding = embeddings[0].tolist()
+        #     query_embedding = embeddings[0].tolist()
             
-            # Create vector query
-            vector_query = VectorQuery(
-                query_text=message.text,
-                k=settings.TOP_K_MATCHES,
-                score_threshold=0.7  # Minimum similarity threshold
-            )
+        #     # Create vector query
+        #     vector_query = VectorQuery(
+        #         query_text=message.text,
+        #         k=self.settings.TOP_K_MATCHES,
+        #         score_threshold=0.7  # Minimum similarity threshold
+        #     )
             
-            # Search for similar content in vector database
-            context_results = await self.vector_database_service.search_by_similarity(
-                query=vector_query,
-                query_embedding=query_embedding
-            )
+        #     # Search for similar content chunks in vector database
+        #     context_results = await self.vector_database_service.search_by_similarity(
+        #         query=vector_query,
+        #         query_embedding=query_embedding
+        #     )
             
-            logger.info(f"Retrieved {len(context_results)} context items for message: {message.key}")
-            return context_results
+        #     logger.info(f"Retrieved {len(context_results)} context items for message: {message.key}")
+        #     return context_results
             
-        except Exception as e:
-            logger.error(f"Error retrieving context for message {message.key}: {str(e)}")
-            return []
-   
+        # except Exception as e:
+        #     logger.error(f"Error retrieving context for message {message.key}: {str(e)}")
+        #     return []
+        return (VectorizedChunk(text="Mock context chunk", parent_id="lol", chunk_id="no", metadata={}),
+                VectorizedChunk(text="Moar mock context chunk", parent_id="lol", chunk_id="wut", metadata={}))

src/ctp_slack_bot/services/embeddings_model_service.py

@@ -0,0 +1,48 @@
+from loguru import logger
+from openai import OpenAI
+from pydantic import BaseModel, PrivateAttr, model_validator
+from typing import Any, Dict, Sequence, Self
+
+from ctp_slack_bot.core import Settings
+
+class EmbeddingsModelService(BaseModel):
+    """
+    Service for embeddings model operations.
+    """
+
+    settings: Settings
+    _open_ai_client: PrivateAttr = PrivateAttr()
+
+    def __init__(self: Self, **data: Dict[str, Any]) -> None:
+        super().__init__(**data)
+        self._open_ai_client = OpenAI(api_key=self.settings.OPENAI_API_KEY.get_secret_value())
+
+    @model_validator(mode='after')
+    def post_init(self: Self) -> Self:
+        logger.debug("Created {}", self.__class__.__name__)
+        return self
+
+    def get_embeddings(self: Self, texts: Sequence[str]) -> Sequence[Sequence[float]]:
+        """Get embeddings for a collection of texts using OpenAI’s API.
+
+        Args:
+            texts (Collection[str]): Collection of text chunks to embed
+            
+        Returns:
+            NDArray: Array of embeddings with shape (n_texts, VECTOR_DIMENSION)
+            
+        Raises:
+            ValueError: If the embedding dimensions don't match expected size
+        """
+        logger.debug("Creating embeddings for {} text string(s)…", len(texts))
+        response = self._open_ai_client.embeddings.create(
+            model=self.settings.EMBEDDING_MODEL,
+            input=texts,
+            encoding_format="float" # Ensure we get raw float values.
+        )
+        embeddings = tuple(tuple(data.embedding) for data in response.data)
+        match embeddings:
+            case (first, _) if len(first) != self.settings.VECTOR_DIMENSION:
+                logger.error("Embedding dimension mismatch and/or misconfiguration: expected configured dimension {}, but got {}.", self.settings.VECTOR_DIMENSION, len(first))
+                raise ValueError() # TODO: raise a more specific type.
+        return embeddings

src/ctp_slack_bot/services/event_brokerage_service.py

@@ -1,38 +1,46 @@
-# from asyncio import create_task
+
+from asyncio import create_task, iscoroutinefunction, to_thread
+from collections import defaultdict
 from loguru import logger
-from openai import OpenAI
-from pydantic import BaseModel, model_validator
+from pydantic import BaseModel, model_validator, PrivateAttr
 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
-
+from ctp_slack_bot.enums import EventType
 
 class EventBrokerageService(BaseModel):
     """
     Service for brokering events between services.
     """
 
-    subscribers: Dict[str, List[Callable]] = {}
-
-    class Config:
-        arbitrary_types_allowed = True
+    _subscribers: PrivateAttr = PrivateAttr(default_factory=lambda: defaultdict(list))
 
     @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:
+    def subscribe(self: Self, type: EventType, 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:
+        logger.debug("1 new subscriber is listening for {} events.", type)
+        subscribers = self._subscribers[type]
+        subscribers.append(callback)
+        logger.debug("Event type {} has {} subscriber(s).", type, len(subscribers))
+
+    def publish(self: Self, type: EventType, 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)
+        subscribers = self._subscribers[type]
+        if not subscribers:
+            logger.debug("No subscribers handle event {}: {}", type, len(subscribers), data)
+            return
+        logger.debug("Broadcasting event {} to {} subscriber(s): {}", type, len(subscribers), data)
+        for callback in subscribers:
+            if iscoroutinefunction(callback):
+                task: create_task(callback(data))
+                task.add_done_callback(lambda done_task: logger.error("Error in asynchronous event callback handling event {}: {}", done_task.exception())
+                                                         if done_task.exception()
+                                                         else None)
+            else:
+                try:
+                    create_task(to_thread(callback, data))
+                except Exception as e:
+                    logger.error("Error scheduling synchronous callback to handle event {}: {}", type, e)

src/ctp_slack_bot/services/language_model_service.py

@@ -0,0 +1,56 @@
+from loguru import logger
+from openai import OpenAI
+from openai.types.chat import ChatCompletion
+from pydantic import BaseModel, PrivateAttr, model_validator
+from typing import Collection, Self
+
+from ctp_slack_bot.core import Settings
+from ctp_slack_bot.models import Chunk
+
+class LanguageModelService(BaseModel):
+    """
+    Service for language model operations.
+    """
+
+    settings: Settings
+    _open_ai_client: PrivateAttr = PrivateAttr()
+
+    def __init__(self: Self, **data) -> None:
+        super().__init__(**data)
+        self._open_ai_client = OpenAI(api_key=self.settings.OPENAI_API_KEY.get_secret_value())
+
+    @model_validator(mode='after')
+    def post_init(self: Self) -> Self:
+        logger.debug("Created {}", self.__class__.__name__)
+        return self
+
+    def answer_question(self, question: str, context: Collection[Chunk]) -> str:
+        """Generate a response using OpenAI’s API with retrieved context.
+        
+        Args:
+            question (str): The user’s question
+            context (List[RetreivedContext]): The context retreived for answering the question
+            
+        Returns:
+            str: Generated answer
+        """
+        logger.debug("Generating response for question “{}” using {} context chunks…", question, len(context))
+        messages = [
+            {"role": "system", "content": self.settings.SYSTEM_PROMPT},
+            {"role": "user", "content": 
+                f"""Student Question: {question}
+
+                Context from class materials and transcripts:
+                {'\n'.join(chunk.text for chunk in context)}
+
+                Please answer the Student Question based on the Context from class materials and transcripts. If the context doesn’t contain relevant information, acknowledge that and suggest asking the professor."""}
+        ]
+        # response: ChatCompletion = self._open_ai_client.chat.completions.create(
+        #     model=self.settings.CHAT_MODEL,
+        #     messages=messages,
+        #     max_tokens=self.settings.MAX_TOKENS,
+        #     temperature=self.settings.TEMPERATURE
+        # )
+        
+        # return response.choices[0].message.content
+        return f"A mock response to “{question}”"

src/ctp_slack_bot/services/question_dispatch_service.py

@@ -1,11 +1,11 @@
 # 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 typing import Self
 
 from ctp_slack_bot.core import Settings
-from ctp_slack_bot.models import RetreivedContext, SlackMessage
+from ctp_slack_bot.enums import EventType
+from ctp_slack_bot.models import Chunk, 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
@@ -24,8 +24,11 @@ class QuestionDispatchService(BaseModel):
     @model_validator(mode='after')
     def post_init(self: Self) -> Self:
         logger.debug("Created {}", self.__class__.__name__)
+        self.event_brokerage_service.subscribe(EventType.INCOMING_SLACK_MESSAGE, self.__process_incoming_slack_message)
         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)
+    def __process_incoming_slack_message(self: Self, message: SlackMessage) -> None:
+        if message.subtype != 'bot_message':
+            logger.debug("Question dispatch service received an answerable question: {}", message.text)
+            context = self.context_retrieval_service.get_context(message)
+            self.answer_retrieval_service.push(message, context)

src/ctp_slack_bot/services/slack_service.py

@@ -1,11 +1,11 @@
-# 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 slack_bolt import App
+from typing import Any, Dict, Self
 
-from ctp_slack_bot.core import Settings
-from ctp_slack_bot.models import RetreivedContext, SlackMessage
+from ctp_slack_bot.enums import EventType
+from ctp_slack_bot.models import SlackMessage, SlackResponse
 from ctp_slack_bot.services.event_brokerage_service import EventBrokerageService
 
 
@@ -14,10 +14,36 @@ class SlackService(BaseModel):
     Service for interfacing with Slack.
     """
 
-    settings: Settings
     event_brokerage_service: EventBrokerageService
+    slack_bolt_app: App
+
+    class Config:
+        arbitrary_types_allowed = True
 
     @model_validator(mode='after')
     def post_init(self: Self) -> Self:
+        self.event_brokerage_service.subscribe(EventType.OUTGOING_SLACK_RESPONSE, self.send_message)
         logger.debug("Created {}", self.__class__.__name__)
         return self
+
+    def adapt_event_payload(self: Self, event: Dict[str, Any]) -> SlackMessage:
+        return SlackMessage(
+            type=event.get("type"),
+            subtype=event.get("subtype"),
+            channel=event.get("channel"),
+            channel_type=event.get("channel_type"),
+            user=event.get("user"),
+            bot_id=event.get("bot_id"),
+            thread_ts=event.get("thread_ts"),
+            text=event.get("text", ""),
+            ts=event.get("ts"),
+            event_ts=event.get("event_ts")
+        )
+
+    def process_message(self: Self, event: Dict[str, Any]) -> None:
+        slack_message = self.adapt_event_payload(event.get("event", {}))
+        logger.debug("Received message from Slack: {}", slack_message)
+        self.event_brokerage_service.publish(EventType.INCOMING_SLACK_MESSAGE, slack_message)
+
+    def send_message(self: Self, message: SlackResponse) -> None:
+        self.slack_bolt_app.client.chat_postMessage(channel=message.channel, text=message.text, thread_ts=message.thread_ts)

src/ctp_slack_bot/services/vector_database_service.py

@@ -1,10 +1,10 @@
 from loguru import logger
 from pydantic import BaseModel, model_validator
-from typing import Any, Dict, List, Optional, Self
+from typing import Any, Collection, Dict, List, Optional, Self, Sequence
 
 from ctp_slack_bot.core import Settings
 from ctp_slack_bot.db import MongoDB
-from ctp_slack_bot.models import VectorQuery, RetreivedContext
+from ctp_slack_bot.models import Chunk, Content, VectorizedChunk, VectorQuery
 
 class VectorDatabaseService(BaseModel): # TODO: this should not rely specifically on MongoDB.
     """
@@ -19,13 +19,15 @@ class VectorDatabaseService(BaseModel): # TODO: this should not rely specificall
         logger.debug("Created {}", self.__class__.__name__)
         return self
 
-    async def initialize(self):
-        """
-        Initialize the database connection.
-        """
-        await mongodb.initialize()
+    # Should not allow initialization calls to bubble up all the way to the surface ― sequester in `post_init` or the class on which it depends.
+    # async def initialize(self) -> None:
+    #     """
+    #     Initialize the database connection.
+    #     """
+    #     await self.mongo_db.initialize()
     
-    async def store(self, text: str, embedding: List[float], metadata: Dict[str, Any]) -> str:
+    # TODO: Weight cost of going all async.
+    async def store(self, chunks: Collection[VectorizedChunk]) -> None:
         """
         Store text and its embedding vector in the database.
         
@@ -37,8 +39,8 @@ class VectorDatabaseService(BaseModel): # TODO: this should not rely specificall
         Returns:
             str: The ID of the stored document
         """
-        if not mongodb.initialized:
-            await mongodb.initialize()
+        if not self.mongo_db.initialized:
+            await self.mongo_db.initialize()
             
         try:
             # Create document to store
@@ -49,7 +51,7 @@ class VectorDatabaseService(BaseModel): # TODO: this should not rely specificall
             }
             
             # Insert into collection
-            result = await mongodb.vector_collection.insert_one(document)
+            result = await self.mongo_db.vector_collection.insert_one(document)
             logger.debug(f"Stored document with ID: {result.inserted_id}")
             
             return str(result.inserted_id)
@@ -57,7 +59,7 @@ class VectorDatabaseService(BaseModel): # TODO: this should not rely specificall
             logger.error(f"Error storing embedding: {str(e)}")
             raise
     
-    async def search_by_similarity(self, query: VectorQuery, query_embedding: List[float]) -> List[RetreivedContext]:
+    async def search_by_similarity(self, query: VectorQuery) -> Sequence[Chunk]:
         """
         Query the vector database for similar documents.
         
@@ -68,8 +70,8 @@ class VectorDatabaseService(BaseModel): # TODO: this should not rely specificall
         Returns:
             List[RetreivedContext]: List of similar documents with similarity scores
         """
-        if not mongodb.initialized:
-            await mongodb.initialize()
+        if not self.mongo_db.initialized:
+            await self.mongo_db.initialize()
             
         try:
             # Build aggregation pipeline for vector search
@@ -100,7 +102,7 @@ class VectorDatabaseService(BaseModel): # TODO: this should not rely specificall
                 pipeline.insert(1, {"$match": metadata_filter})
             
             # Execute the pipeline
-            results = await mongodb.vector_collection.aggregate(pipeline).to_list(length=query.k)
+            results = await self.mongo_db.vector_collection.aggregate(pipeline).to_list(length=query.k)
             
             # Convert to RetreivedContext objects directly
             context_results = []
@@ -113,7 +115,7 @@ class VectorDatabaseService(BaseModel): # TODO: this should not rely specificall
                     continue
                     
                 context_results.append(
-                    RetreivedContext(
+                    Content(
                         contextual_text=result["text"],
                         metadata_source=result["metadata"].get("source", "unknown"),
                         similarity_score=normalized_score,

src/ctp_slack_bot/services/vectorization_service.py

@@ -1,10 +1,13 @@
 from loguru import logger
-import numpy as np
+from numpy import array
+from numpy.typing import NDArray
 from openai import OpenAI
 from pydantic import BaseModel, model_validator
-from typing import List, Optional, Self
+from typing import Self, Sequence
 
 from ctp_slack_bot.core import Settings
+from ctp_slack_bot.models import Chunk, VectorizedChunk
+from ctp_slack_bot.services.embeddings_model_service import EmbeddingsModelService
 
 class VectorizationService(BaseModel):
     """
@@ -12,57 +15,21 @@ class VectorizationService(BaseModel):
     """
 
     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
+    embeddings_model_service: EmbeddingsModelService
 
     @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.
-        
-        Args:
-            texts (List[str]): List of text chunks to embed
-            
-        Returns:
-            np.ndarray: Array of embeddings with shape (n_texts, VECTOR_DIMENSION)
-            
-        Raises:
-            ValueError: If the embedding dimensions don't match expected size
-        """
-        try:
-            # Use the initialized client instead of the global openai module
-            response = self.client.embeddings.create(
-                model=self.settings.EMBEDDING_MODEL,
-                input=texts,
-                encoding_format="float"  # Ensure we get raw float values
-            )
-            
-            # Extract embeddings and verify dimensions
-            embeddings = np.array([data.embedding for data in response.data])
-            
-            if embeddings.shape[1] != self.settings.VECTOR_DIMENSION:
-                raise ValueError(
-                    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."
-                )
-                
-            return embeddings 
-            
-        except Exception as e:
-            print(f"Error getting embeddings: {str(e)}")
-            pass
 
-    def _test(self, list_of_strings: List[str] = ['Hello my sweet Svetlana.', 'You mean the world to me.']):
-        """
-        Test the vectorization service.
-        """
-        print('embedding list', list_of_strings)
-        embeddings = self.get_embeddings(list_of_strings)
-        print(embeddings)
-        return embeddings
+    def vectorize(self: Self, chunks: Sequence[Chunk]) -> Sequence[VectorizedChunk]:
+        embeddings = self.embeddings_model_service.get_embeddings([chunk.text for chunk in chunks])
+        return tuple(VectorizedChunk(
+                         text=chunk.text,
+                         parent_id=chunk.parent_id,
+                         chunk_id=chunk.chunk_id,
+                         metadata=chunk.metadata,
+                         embedding=embedding
+                     )
+                     for chunk, embedding
+                     in zip(chunks, embeddings))

src/ctp_slack_bot/tasks/scheduler.py

@@ -6,7 +6,7 @@ from loguru import logger
 from pytz import timezone
 from typing import Optional
 
-from ctp_slack_bot import Container
+from ctp_slack_bot.containers import Container
 
 @inject
 def start_scheduler(container: Container) -> AsyncIOScheduler: