Convert more service methods to async; drop `VectorDatabaseService` intermediary and use the repository classes directly

notebooks/container.ipynb

@@ -1,102 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Loading Dependency Injection Container in Jupyter Notebook"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from ctp_slack_bot.containers import Container\n",
-    "from ctp_slack_bot.services import VectorDatabaseService\n",
-    "\n",
-    "container = Container()\n",
-    "container.wire(packages=['ctp_slack_bot'])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\u001b[32m2025-04-19 16:43:46.927\u001b[0m | \u001b[34m\u001b[1mDEBUG   \u001b[0m | \u001b[36mctp_slack_bot.core.config\u001b[0m:\u001b[36m__init__\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1mCreated Settings\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "Settings(LOG_LEVEL='INFO', LOG_FORMAT='json', SCHEDULER_TIMEZONE='America/New_York', SLACK_BOT_TOKEN=SecretStr('**********'), SLACK_APP_TOKEN=SecretStr('**********'), EMBEDDING_MODEL='text-embedding-3-small', VECTOR_DIMENSION=1536, CHUNK_SIZE=1000, CHUNK_OVERLAP=200, TOP_K_MATCHES=5, MONGODB_URI=SecretStr('**********'), MONGODB_NAME='ctp_slack_bot', SCORE_THRESHOLD=0.5, HF_API_TOKEN=SecretStr('**********'), OPENAI_API_KEY=SecretStr('**********'), CHAT_MODEL='gpt-3.5-turbo', MAX_TOKENS=150, TEMPERATURE=0.8, SYSTEM_PROMPT=\"You are a helpful teaching assistant for a data science class.\\nBased on the students question, you will be given context retreived from class transcripts and materials to answer their question.\\nYour responses should be:\\n\\n1. Accurate and based on the class content\\n2. Clear and educational\\n3. Concise but complete\\nIf you're unsure about something, acknowledge it and suggest asking the professor.\", GOOGLE_PROJECT_ID='voltaic-reducer-294821', GOOGLE_PRIVATE_KEY_ID=SecretStr('**********'), GOOGLE_PRIVATE_KEY=SecretStr('**********'), GOOGLE_CLIENT_ID='102943207835073856980', GOOGLE_CLIENT_EMAIL='[email protected]', GOOGLE_AUTH_URI='https://accounts.google.com/o/oauth2/auth', GOOGLE_TOKEN_URI='https://oauth2.googleapis.com/token', GOOGLE_AUTH_PROVIDER_CERT_URL='https://www.googleapis.com/oauth2/v1/certs', GOOGLE_CLIENT_CERT_URL='https://www.googleapis.com/robot/v1/metadata/x509/ctp-slack-bot-714%40voltaic-reducer-294821.iam.gserviceaccount.com', GOOGLE_UNIVERSE_DOMAIN='googleapis.com', FILE_MONITOR_ROOT_PATH='Transcripts/Friday Building AI Applications Session')"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "container.settings()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\u001b[32m2025-04-19 16:45:25.997\u001b[0m | \u001b[34m\u001b[1mDEBUG   \u001b[0m | \u001b[36mctp_slack_bot.core.config\u001b[0m:\u001b[36m__init__\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1mCreated Settings\u001b[0m\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\u001b[32m2025-04-19 16:45:25.999\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mctp_slack_bot.db.mongo_db\u001b[0m:\u001b[36minit\u001b[0m:\u001b[36m175\u001b[0m - \u001b[1mInitializing MongoDB connection for database: ctp_slack_bot\u001b[0m\n",
-      "\u001b[32m2025-04-19 16:45:25.999\u001b[0m | \u001b[34m\u001b[1mDEBUG   \u001b[0m | \u001b[36mctp_slack_bot.db.mongo_db\u001b[0m:\u001b[36m__init__\u001b[0m:\u001b[36m26\u001b[0m - \u001b[34m\u001b[1mCreated MongoDB\u001b[0m\n",
-      "\u001b[32m2025-04-19 16:45:25.999\u001b[0m | \u001b[34m\u001b[1mDEBUG   \u001b[0m | \u001b[36mctp_slack_bot.db.mongo_db\u001b[0m:\u001b[36mconnect\u001b[0m:\u001b[36m32\u001b[0m - \u001b[34m\u001b[1mConnecting to MongoDB using URI: mongodb+srv://ctp-slack-bot.xkipuvm.mongodb.net/?retryWrites=true&w=majority&appName=ctp-slack-bot\u001b[0m\n",
-      "\u001b[32m2025-04-19 16:45:26.000\u001b[0m | \u001b[34m\u001b[1mDEBUG   \u001b[0m | \u001b[36mctp_slack_bot.db.mongo_db\u001b[0m:\u001b[36mconnect\u001b[0m:\u001b[36m49\u001b[0m - \u001b[34m\u001b[1mMongoDB client initialized for database: ctp_slack_bot\u001b[0m\n",
-      "\u001b[32m2025-04-19 16:45:26.279\u001b[0m | \u001b[34m\u001b[1mDEBUG   \u001b[0m | \u001b[36mctp_slack_bot.db.mongo_db\u001b[0m:\u001b[36mping\u001b[0m:\u001b[36m85\u001b[0m - \u001b[34m\u001b[1mMongoDB connection is active!\u001b[0m\n",
-      "\u001b[32m2025-04-19 16:45:26.280\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mctp_slack_bot.db.mongo_db\u001b[0m:\u001b[36m_test_connection\u001b[0m:\u001b[36m186\u001b[0m - \u001b[1mMongoDB connection test successful!\u001b[0m\n",
-      "\u001b[32m2025-04-19 16:45:26.280\u001b[0m | \u001b[34m\u001b[1mDEBUG   \u001b[0m | \u001b[36mctp_slack_bot.services.vector_database_service\u001b[0m:\u001b[36m__init__\u001b[0m:\u001b[36m21\u001b[0m - \u001b[34m\u001b[1mCreated VectorDatabaseService\u001b[0m\n"
-     ]
-    }
-   ],
-   "source": [
-    "vector_database_service: VectorDatabaseService = container.vector_database_service()"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

notebooks/google_drive_web_vtt_vectorizer_and_storer.ipynb

@@ -30,7 +30,7 @@
     "mongo_db = await container.mongo_db()\n",
     "google_drive_service = container.google_drive_service()\n",
     "vectorization_service = container.vectorization_service()\n",
-    "vector_database_service = await container.vector_database_service()"
+    "vectorized_chunk_repository = await container.vectorized_chunk_repository()"
    ]
   },
   {
@@ -50,7 +50,7 @@
    "source": [
     "MIME_TYPE = \"text/vtt\" # This should probably not be changed.\n",
     "\n",
-    "MODIFICATION_TIME_CUTOFF = datetime(2024, 8, 30, tzinfo=ZoneInfo(\"UTC\"))"
+    "MODIFICATION_TIME_CUTOFF = datetime(2024, 7, 1, tzinfo=ZoneInfo(\"UTC\"))"
    ]
   },
   {
@@ -117,10 +117,28 @@
     "for web_vtt in web_vtts:\n",
     "    chunks = web_vtt.get_chunks()\n",
     "    display_html(f\"Chunked {web_vtt.get_metadata().get(\"filename\")} into {len(chunks)} chunks.\")\n",
-    "    vectorized_chunks = vectorization_service.vectorize(chunks)\n",
+    "    vectorized_chunks = await vectorization_service.vectorize(chunks)\n",
     "    display_html(f\"Vectorized {web_vtt.get_metadata().get(\"filename\")}’s {len(vectorized_chunks)} chunks.\")\n",
-    "    await vector_database_service.store(vectorized_chunks)\n",
-    "    display_html(f\"Stored {web_vtt.get_metadata().get(\"filename\")}’s {len(vectorized_chunks)} vectorized chunks to the database.\")"
+    "    inserted_ids = await vectorized_chunk_repository.insert_many(vectorized_chunks)\n",
+    "    display_html(f\"Stored {web_vtt.get_metadata().get(\"filename\")}’s {len(inserted_ids)} vectorized chunks to the database.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Close MongoDB Connection\n",
+    "\n",
+    "Don’t forget to clean up…"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mongo_db.close()"
    ]
   }
  ],

src/ctp_slack_bot/containers.py

@@ -19,14 +19,13 @@ 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.schedule_service import ScheduleServiceResource
 from ctp_slack_bot.services.slack_service import SlackServiceResource
-from ctp_slack_bot.services.vector_database_service import VectorDatabaseService
 from ctp_slack_bot.services.vectorization_service import VectorizationService
 
 
 def __load_plugins(plugin_dir) -> None:
     for path in Path(plugin_dir).glob("*.py"):
         if path.stem == "__init__":
-            continue  # Skip __init__.py files
+            continue # Skip __init__.py files
         module_name = f"{plugin_dir.replace('/', '.')}.{path.stem}"
         import_module(module_name)
 
@@ -35,7 +34,7 @@ __load_plugins("ctp_slack_bot/mime_type_handlers")
 
 
 class Container(DeclarativeContainer): # TODO: audit for potential async-related bugs.
-    settings = Singleton(Settings)
+    settings                    = Singleton(Settings)
     event_brokerage_service     = Singleton(EventBrokerageService)
     schedule_service            = Resource (ScheduleServiceResource,
                                             settings=settings)
@@ -44,9 +43,6 @@ class Container(DeclarativeContainer): # TODO: audit for potential async-related
     vectorized_chunk_repository = Resource (MongoVectorizedChunkRepositoryResource,
                                             settings=settings,
                                             mongo_db=mongo_db)
-    vector_database_service     = Singleton(VectorDatabaseService,
-                                            settings=settings,
-                                            vectorized_chunk_repository=vectorized_chunk_repository)
     embeddings_model_service    = Singleton(EmbeddingsModelService,
                                             settings=settings)
     vectorization_service       = Singleton(VectorizationService,
@@ -55,12 +51,12 @@ class Container(DeclarativeContainer): # TODO: audit for potential async-related
     content_ingestion_service   = Singleton(ContentIngestionService,
                                             settings=settings,
                                             event_brokerage_service=event_brokerage_service,
-                                            vector_database_service=vector_database_service,
+                                            vectorized_chunk_repository=vectorized_chunk_repository,
                                             vectorization_service=vectorization_service)
     context_retrieval_service   = Singleton(ContextRetrievalService,
                                             settings=settings,
                                             vectorization_service=vectorization_service,
-                                            vector_database_service=vector_database_service)
+                                            vectorized_chunk_repository=vectorized_chunk_repository)
     language_model_service      = Singleton(LanguageModelService,
                                             settings=settings)
     answer_retrieval_service    = Singleton(AnswerRetrievalService,

src/ctp_slack_bot/services/__init__.py

@@ -7,5 +7,4 @@ from ctp_slack_bot.services.google_drive_service import GoogleDriveService
 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
 from ctp_slack_bot.services.vectorization_service import VectorizationService

src/ctp_slack_bot/services/answer_retrieval_service.py

@@ -28,7 +28,7 @@ class AnswerRetrievalService(BaseModel):
     async 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)
+        answer = await self.language_model_service.answer_question(question.text, context)
         logger.debug("Pushing response to channel {} and thread {}: {}", channel_to_respond_to, thread_to_respond_to, answer)
         slack_response = SlackResponse(text=answer, channel=channel_to_respond_to, thread_ts=thread_to_respond_to)
         await self.event_brokerage_service.publish(EventType.OUTGOING_SLACK_RESPONSE, slack_response)

src/ctp_slack_bot/services/content_ingestion_service.py

@@ -1,12 +1,12 @@
 from loguru import logger
 from pydantic import BaseModel
-from typing import Self, Sequence
+from typing import Self, Sequence, Set
 
 from ctp_slack_bot.core import Settings
+from ctp_slack_bot.db.repositories import VectorizedChunkRepository
 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
 
 class ContentIngestionService(BaseModel):
@@ -16,7 +16,7 @@ class ContentIngestionService(BaseModel):
 
     settings: Settings
     event_brokerage_service: EventBrokerageService
-    vector_database_service: VectorDatabaseService
+    vectorized_chunk_repository: VectorizedChunkRepository
     vectorization_service: VectorizationService
 
     class Config:
@@ -30,19 +30,19 @@ class ContentIngestionService(BaseModel):
 
     async 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.content_exists(content.get_id()):
+        if self.vectorized_chunk_repository.count_by_id(content.get_id()):
            logger.debug("Ignored content with identifier, {}, because it already exists in the database.", content.get_id())
            return
         chunks = content.get_chunks()
-        await self.__vectorize_and_store_chunks_in_database(chunks)
-        logger.debug("Stored {} vectorized chunk(s) in the database.", len(chunks))
+        inserted_ids = await self.__vectorize_and_store_chunks_in_database(chunks)
+        logger.debug("Stored {} vectorized chunk(s) in the database.", len(inserted_ids))
 
     async 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()
-        await self.__vectorize_and_store_chunks_in_database(chunks)
-        logger.debug("Stored {} vectorized chunk(s) in the database.", len(chunks))
+        inserted_ids = await self.__vectorize_and_store_chunks_in_database(chunks)
+        logger.debug("Stored {} vectorized chunk(s) in the database.", len(inserted_ids))
 
-    async def __vectorize_and_store_chunks_in_database(self: Self, chunks: Sequence[Chunk]) -> None:
-        vectorized_chunks = self.vectorization_service.vectorize(chunks)
-        await self.vector_database_service.store(vectorized_chunks)
+    async def __vectorize_and_store_chunks_in_database(self: Self, chunks: Sequence[Chunk]) -> Set[str]:
+        vectorized_chunks = await self.vectorization_service.vectorize(chunks)
+        return await self.vectorized_chunk_repository.insert_many(vectorized_chunks)

src/ctp_slack_bot/services/context_retrieval_service.py

@@ -3,8 +3,8 @@ from pydantic import BaseModel
 from typing import Self, Sequence
 
 from ctp_slack_bot.core.config import Settings
+from ctp_slack_bot.db.repositories import VectorizedChunkRepository
 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
 
 class ContextRetrievalService(BaseModel):
@@ -14,7 +14,7 @@ class ContextRetrievalService(BaseModel):
 
     settings: Settings
     vectorization_service: VectorizationService
-    vector_database_service: VectorDatabaseService
+    vectorized_chunk_repository: VectorizedChunkRepository
 
     class Config:
         frozen=True
@@ -37,7 +37,7 @@ class ContextRetrievalService(BaseModel):
         message_chunks = message.get_chunks() # Guaranteed to have exactly 1 chunk
 
         try:
-            vectorized_message_chunks = self.vectorization_service.vectorize(message_chunks)
+            vectorized_message_chunks = await self.vectorization_service.vectorize(message_chunks)
         except Exception as e:
             logger.error("An error occurred while vectorizing the question, “{}”: {}", message.text, e)
 
@@ -49,7 +49,8 @@ class ContextRetrievalService(BaseModel):
         )
 
         try:
-            results = await self.vector_database_service.find_by_vector(query)
+            results = await self.vectorized_chunk_repository.find_by_vector(query)
+            logger.debug("Found {} chunks in the database by similarity search.", len(results))
             return results
         except Exception as e:
             logger.error("An error occurred while searching the vector database for context: {}", e)

src/ctp_slack_bot/services/embeddings_model_service.py

@@ -1,5 +1,5 @@
 from loguru import logger
-from openai import OpenAI
+from openai import AsyncOpenAI
 from pydantic import BaseModel, PrivateAttr
 from typing import Any, Dict, Sequence, Self
 
@@ -18,10 +18,10 @@ class EmbeddingsModelService(BaseModel):
 
     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())
+        self._open_ai_client = AsyncOpenAI(api_key=self.settings.OPENAI_API_KEY.get_secret_value())
         logger.debug("Created {}", self.__class__.__name__)
 
-    def get_embeddings(self: Self, texts: Sequence[str]) -> Sequence[Sequence[float]]:
+    async def get_embeddings(self: Self, texts: Sequence[str]) -> Sequence[Sequence[float]]:
         """Get embeddings for a collection of texts using OpenAI’s API.
 
         Args:
@@ -34,7 +34,7 @@ class EmbeddingsModelService(BaseModel):
             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(
+        response = await self._open_ai_client.embeddings.create(
             model=self.settings.EMBEDDING_MODEL,
             input=texts,
             encoding_format="float" # Ensure we get raw float values.

src/ctp_slack_bot/services/language_model_service.py

@@ -1,5 +1,5 @@
 from loguru import logger
-from openai import OpenAI
+from openai import AsyncOpenAI
 from openai.types.chat import ChatCompletion
 from pydantic import BaseModel, PrivateAttr
 from typing import Collection, Self
@@ -20,10 +20,10 @@ class LanguageModelService(BaseModel):
 
     def __init__(self: Self, **data) -> None:
         super().__init__(**data)
-        self._open_ai_client = OpenAI(api_key=self.settings.OPENAI_API_KEY.get_secret_value())
+        self._open_ai_client = AsyncOpenAI(api_key=self.settings.OPENAI_API_KEY.get_secret_value())
         logger.debug("Created {}", self.__class__.__name__)
 
-    def answer_question(self, question: str, context: Collection[Chunk]) -> str:
+    async def answer_question(self, question: str, context: Collection[Chunk]) -> str:
         """Generate a response using OpenAI’s API with retrieved context.
         
         Args:
@@ -45,7 +45,7 @@ class LanguageModelService(BaseModel):
 
                 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. Otherwise, carry on."""}
         ]
-        response: ChatCompletion = self._open_ai_client.chat.completions.create(
+        response: ChatCompletion = await self._open_ai_client.chat.completions.create(
             model=self.settings.CHAT_MODEL,
             messages=messages,
             max_tokens=self.settings.MAX_TOKENS,

src/ctp_slack_bot/services/question_dispatch_service.py

@@ -1,4 +1,3 @@
-# from asyncio import create_task
 from loguru import logger
 from pydantic import BaseModel
 from typing import Self

src/ctp_slack_bot/services/vector_database_service.py

@@ -1,67 +0,0 @@
-from loguru import logger
-from pydantic import BaseModel
-from typing import Iterable, Optional, Self, Sequence
-
-from ctp_slack_bot.core import Settings
-from ctp_slack_bot.db.repositories import VectorizedChunkRepository
-from ctp_slack_bot.models import Chunk, VectorizedChunk, VectorQuery
-
-class VectorDatabaseService(BaseModel): # TODO: this should not rely specifically on MongoDB.
-    """
-    Service for storing and retrieving vector embeddings from MongoDB.
-    """
-
-    settings: Settings
-    vectorized_chunk_repository: VectorizedChunkRepository
-
-    class Config:
-        frozen=True
-
-    def __init__(self: Self, **data) -> None:
-        super().__init__(**data)
-        logger.debug("Created {}", self.__class__.__name__)
-    
-    async def content_exists(self: Self, parent_id: str, chunk_id: Optional[str] = None)-> bool:
-        """
-        Check if the content identified by the parent and optionally the chunk identifiers exist in the database.
-        
-        Args:
-            parent_id: the identifier of the source content
-            chunk_id:  the identifier of the chunk within the source content
-        """
-        matching_chunk_count = await self.vectorized_chunk_repository.count_by_id(parent_id, chunk_id)
-        return 0 < matching_chunk_count
-
-    async def find_by_vector(self: Self, query: VectorQuery) -> Sequence[Chunk]:
-        """
-        Query the vector database for similar chunks.
-
-        Args:
-            query: the query criteria
-     
-        Returns:
-            Sequence[Chunk]: an ordered collection of similar chunks
-        """
-        try:
-            result = await self.vectorized_chunk_repository.find_by_vector(query)
-            logger.debug("Found {} chunks in the database by similarity search.", len(result))
-            return result
-        except Exception as e:
-            logger.error("Error finding chunks by vector: {}", str(e))
-            raise
-
-    async def store(self: Self, chunks: Iterable[VectorizedChunk]) -> None:
-        """
-        Stores vectorized chunks and their embedding vectors in the database.
-
-        Args:
-            chunks: a collection of vectorized chunks to store
-
-        Returns: None
-        """
-        try:
-            inserted_ids = await self.vectorized_chunk_repository.insert_many(chunks)
-            logger.debug("Stored {} vectorized chunks in the database.", len(inserted_ids))
-        except Exception as e:
-            logger.error("Error storing vectorized chunks: {}", str(e))
-            raise

src/ctp_slack_bot/services/vectorization_service.py

@@ -21,8 +21,8 @@ class VectorizationService(BaseModel):
         super().__init__(**data)
         logger.debug("Created {}", self.__class__.__name__)
 
-    def vectorize(self: Self, chunks: Sequence[Chunk]) -> Sequence[VectorizedChunk]:
-        embeddings = self.embeddings_model_service.get_embeddings([chunk.text for chunk in chunks])
+    async def vectorize(self: Self, chunks: Sequence[Chunk]) -> Sequence[VectorizedChunk]:
+        embeddings = await self.embeddings_model_service.get_embeddings([chunk.text for chunk in chunks])
         return tuple(VectorizedChunk(
                          text=chunk.text,
                          parent_id=chunk.parent_id,