Add app and data files

app.py

@@ -0,0 +1,145 @@
+import os
+import time
+from pathlib import Path
+
+import streamlit as st
+
+from src import bible_loader
+from src.embeddings import EmbeddingsManager
+from src.reranker import (
+    CombinedScoreAndNumberReranker,
+    MaxVerseReranker,
+    Reranker,
+    SemanticSimScoreReranker,
+)
+from src.retriever import Retriever, SemanticRetriever
+
+
+def display_chapter(chapter):
+    st.header(f"[{str(chapter)}]({chapter.get_biblegateway_url()})")
+    chapter_text = chapter.get_formatted_text()
+    st.markdown(chapter_text, unsafe_allow_html=True)
+    # st.write(chapter.highlight_verses_df)
+
+
+def config():
+    n_results = st.sidebar.slider("Maximum Results?", 5, 30, 10)
+    # bible_version = st.sidebar.selectbox("Bible Version", ["NIV", "ESV"]) # TODO
+    bible_version = "NIV"
+    new_testament = st.sidebar.checkbox("Search New Testament?", True)
+    old_testament = st.sidebar.checkbox("Search Old Testament?", False)
+
+    return n_results, new_testament, old_testament, bible_version
+
+
+def main():
+
+    st.set_page_config(page_title="Bible Search", layout="wide")
+
+    n_results, new_testament, old_testament, bible_version = config()
+
+    # Config
+    ROOT_DIR = Path(os.path.abspath(os.path.dirname(__file__)))
+    DATA_DIR = ROOT_DIR / "data"
+
+    n_candidates = n_results * 2
+    metadata_csv = DATA_DIR / "key_english.csv"
+    verses_csv = DATA_DIR / f"{bible_version}.csv"
+
+    semantic_sim_model = "msmarco-distilbert-base-v4"
+
+    # Initialize / Index
+    bible_df = bible_loader.load_bible(metadata_csv, verses_csv)
+    embeddings_manager = EmbeddingsManager(
+        model_name=semantic_sim_model,
+        bible_version=bible_version,
+        embeddings_cache_dir=DATA_DIR,
+        texts=bible_df["text"].tolist(),
+    )
+
+    # Trim down search space if needed
+    if not new_testament:
+        bible_df = bible_df[bible_df["testament"] != "NT"]
+    if not old_testament:
+        bible_df = bible_df[bible_df["testament"] != "OT"]
+
+    # Initialize retriever and reranker based on filtered texts
+    retriever = SemanticRetriever(bible_df, embeddings_manager)
+    reranker = CombinedScoreAndNumberReranker()
+    # reranker = SemanticSimScoreReranker()
+    # reranker = MaxVerseReranker()
+
+    _, main_col, _ = st.columns([1, 2, 1])
+
+    with main_col:
+
+        # Get user input
+        st.title("Verse Similarity Search")
+        st.markdown(
+            "- Have you ever been stumped by a verse and wondered what related things the Bible says about it?\n"
+            "- Or you have a verse of interest and you simply want to find related ones?\n"
+            "- Or you vaguely recall a verse's idea, but can't recall the exact text?\n"
+            "This tool was made just for that!"
+        )
+
+        st.markdown("---")
+
+        demo_query = st.selectbox(
+            "Try some demo queries...",
+            [
+                "",
+                "For God so loved the world that he gave his one and only Son, that whoever believes in him shall not perish but have eternal life.",
+                "In the same way, faith by itself, if it is not accompanied by action, is dead.",
+                "I tell you the truth, no one can enter the kingdom of God unless he is born of water and the Spirit.",
+                "the Lord is patient with us, not wanting us to perish",
+                "is it ok for believers to continue in sin?",
+                "it is possible to resist every temptation",
+                "heavenly rewards",
+                "the old is gone, the new has come",
+                "suffering for Christ",
+                "rejoicing in trials",
+                "Be careful of false prophets, wolves in sheep skin",
+                "will there be marriage in heaven?",
+            ],
+            index=1,
+        )
+
+        query = st.text_area(
+            "Or type a verse's text here to find similar verses",
+            demo_query if demo_query.strip() else "",
+        )
+
+        clicked_search = st.button("Search", type="primary")
+
+        if query or clicked_search:
+
+            if len(bible_df) == 0:
+                st.markdown(
+                    "---\n:red[Please select at least one testament to search through (left hand side of the screen). :)]"
+                )
+            else:
+                with st.spinner("Searching..."):
+
+                    start = time.time()
+
+                    # Retrieve and re-rank
+                    candidate_chapters = retriever.retrieve(query, n=n_candidates)
+                    candidate_chapters = reranker.rerank(candidate_chapters)
+
+                    # Trim because candidates can be more than the desired results
+                    final_chapter_results = candidate_chapters[:n_results]
+
+                    # Display quick stats
+                    st.markdown(
+                        f"_{len(final_chapter_results)} results found in {time.time()-start:.2f}s_"
+                    )
+                    st.markdown("---")
+
+                    # Display results
+                    for chapter in final_chapter_results:
+                        display_chapter(chapter)
+                        st.markdown("---")
+
+
+if __name__ == "__main__":
+    main()

data/key_english.csv

@@ -0,0 +1,67 @@
+b,n,t,g
+1,Genesis,OT,1
+2,Exodus,OT,1
+3,Leviticus,OT,1
+4,Numbers,OT,1
+5,Deuteronomy,OT,1
+6,Joshua,OT,2
+7,Judges,OT,2
+8,Ruth,OT,2
+9,1 Samuel,OT,2
+10,2 Samuel,OT,2
+11,1 Kings,OT,2
+12,2 Kings,OT,2
+13,1 Chronicles,OT,2
+14,2 Chronicles,OT,2
+15,Ezra,OT,2
+16,Nehemiah,OT,2
+17,Esther,OT,2
+18,Job,OT,3
+19,Psalms,OT,3
+20,Proverbs,OT,3
+21,Ecclesiastes,OT,3
+22,Song of Solomon,OT,3
+23,Isaiah,OT,4
+24,Jeremiah,OT,4
+25,Lamentations,OT,4
+26,Ezekiel,OT,4
+27,Daniel,OT,4
+28,Hosea,OT,4
+29,Joel,OT,4
+30,Amos,OT,4
+31,Obadiah,OT,4
+32,Jonah,OT,4
+33,Micah,OT,4
+34,Nahum,OT,4
+35,Habakkuk,OT,4
+36,Zephaniah,OT,4
+37,Haggai,OT,4
+38,Zechariah,OT,4
+39,Malachi,OT,4
+40,Matthew,NT,5
+41,Mark,NT,5
+42,Luke,NT,5
+43,John,NT,5
+44,Acts,NT,6
+45,Romans,NT,7
+46,1 Corinthians,NT,7
+47,2 Corinthians,NT,7
+48,Galatians,NT,7
+49,Ephesians,NT,7
+50,Philippians,NT,7
+51,Colossians,NT,7
+52,1 Thessalonians,NT,7
+53,2 Thessalonians,NT,7
+54,1 Timothy,NT,7
+55,2 Timothy,NT,7
+56,Titus,NT,7
+57,Philemon,NT,7
+58,Hebrews,NT,7
+59,James,NT,7
+60,1 Peter,NT,7
+61,2 Peter,NT,7
+62,1 John,NT,7
+63,2 John,NT,7
+64,3 John,NT,7
+65,Jude,NT,7
+66,Revelation,NT,8

requirements.txt

@@ -0,0 +1,255 @@
+#
+# This file is autogenerated by pip-compile with Python 3.7
+# by the following command:
+#
+#    pip-compile --output-file=requirements.txt requirements.in
+#
+altair==4.2.0
+    # via streamlit
+attrs==22.1.0
+    # via jsonschema
+backports-zoneinfo==0.2.1
+    # via
+    #   pytz-deprecation-shim
+    #   tzlocal
+black==22.12.0
+    # via -r requirements.in
+blinker==1.5
+    # via streamlit
+cachetools==5.2.0
+    # via streamlit
+certifi==2022.12.7
+    # via requests
+charset-normalizer==2.1.1
+    # via requests
+click==8.0.4
+    # via
+    #   black
+    #   nltk
+    #   streamlit
+decorator==5.1.1
+    # via validators
+entrypoints==0.4
+    # via altair
+filelock==3.8.2
+    # via
+    #   huggingface-hub
+    #   transformers
+gitdb==4.0.10
+    # via gitpython
+gitpython==3.1.29
+    # via streamlit
+h5py==3.7.0
+    # via -r requirements.in
+huggingface-hub==0.11.1
+    # via
+    #   sentence-transformers
+    #   transformers
+idna==3.4
+    # via requests
+importlib-metadata==5.1.0
+    # via
+    #   click
+    #   huggingface-hub
+    #   jsonschema
+    #   streamlit
+    #   transformers
+importlib-resources==5.10.1
+    # via jsonschema
+isort==5.11.4
+    # via -r requirements.in
+jinja2==3.1.2
+    # via
+    #   altair
+    #   pydeck
+joblib==1.2.0
+    # via
+    #   nltk
+    #   scikit-learn
+jsonschema==4.17.3
+    # via altair
+loguru==0.6.0
+    # via -r requirements.in
+markdown-it-py==2.1.0
+    # via rich
+markupsafe==2.1.1
+    # via jinja2
+mdurl==0.1.2
+    # via markdown-it-py
+mypy-extensions==0.4.3
+    # via black
+nltk==3.8
+    # via sentence-transformers
+numpy==1.21.6
+    # via
+    #   -r requirements.in
+    #   altair
+    #   h5py
+    #   pandas
+    #   pyarrow
+    #   pydeck
+    #   scikit-learn
+    #   scipy
+    #   sentence-transformers
+    #   sparse-dot-topn
+    #   streamlit
+    #   torchvision
+    #   transformers
+nvidia-cublas-cu11==11.10.3.66
+    # via
+    #   nvidia-cudnn-cu11
+    #   torch
+nvidia-cuda-nvrtc-cu11==11.7.99
+    # via torch
+nvidia-cuda-runtime-cu11==11.7.99
+    # via torch
+nvidia-cudnn-cu11==8.5.0.96
+    # via torch
+packaging==22.0
+    # via
+    #   huggingface-hub
+    #   streamlit
+    #   transformers
+pandas==1.3.5
+    # via
+    #   -r requirements.in
+    #   altair
+    #   streamlit
+pathspec==0.10.3
+    # via black
+pillow==9.3.0
+    # via
+    #   streamlit
+    #   torchvision
+pkgutil-resolve-name==1.3.10
+    # via jsonschema
+platformdirs==2.6.0
+    # via black
+protobuf==3.19.6
+    # via
+    #   -r requirements.in
+    #   streamlit
+pyarrow==10.0.1
+    # via streamlit
+pydantic==1.10.2
+    # via -r requirements.in
+pydeck==0.8.0
+    # via streamlit
+pygments==2.14.0
+    # via rich
+pympler==1.0.1
+    # via streamlit
+pyrsistent==0.19.2
+    # via jsonschema
+python-dateutil==2.8.2
+    # via
+    #   pandas
+    #   streamlit
+pytz==2022.6
+    # via pandas
+pytz-deprecation-shim==0.1.0.post0
+    # via tzlocal
+pyyaml==6.0
+    # via
+    #   huggingface-hub
+    #   transformers
+regex==2022.10.31
+    # via
+    #   nltk
+    #   transformers
+requests==2.28.1
+    # via
+    #   huggingface-hub
+    #   streamlit
+    #   torchvision
+    #   transformers
+rich==13.3.1
+    # via streamlit
+scikit-learn==1.0.2
+    # via sentence-transformers
+scipy==1.7.3
+    # via
+    #   scikit-learn
+    #   sentence-transformers
+    #   sparse-dot-topn
+semver==2.13.0
+    # via streamlit
+sentence-transformers==2.2.2
+    # via -r requirements.in
+sentencepiece==0.1.91
+    # via sentence-transformers
+six==1.16.0
+    # via python-dateutil
+sklearn==0.0.post1
+    # via -r requirements.in
+smmap==5.0.0
+    # via gitdb
+sparse-dot-topn==0.3.3
+    # via -r requirements.in
+streamlit==1.17.0
+    # via -r requirements.in
+threadpoolctl==3.1.0
+    # via scikit-learn
+tokenizers==0.13.2
+    # via transformers
+toml==0.10.2
+    # via streamlit
+tomli==2.0.1
+    # via black
+toolz==0.12.0
+    # via altair
+torch==1.13.1
+    # via
+    #   -r requirements.in
+    #   sentence-transformers
+    #   torchvision
+torchvision==0.14.1
+    # via sentence-transformers
+tornado==6.2
+    # via streamlit
+tqdm==4.64.1
+    # via
+    #   huggingface-hub
+    #   nltk
+    #   sentence-transformers
+    #   transformers
+transformers==4.25.1
+    # via
+    #   -r requirements.in
+    #   sentence-transformers
+typed-ast==1.5.4
+    # via black
+typing-extensions==4.4.0
+    # via
+    #   black
+    #   gitpython
+    #   huggingface-hub
+    #   importlib-metadata
+    #   jsonschema
+    #   markdown-it-py
+    #   pydantic
+    #   rich
+    #   streamlit
+    #   torch
+    #   torchvision
+tzdata==2022.7
+    # via pytz-deprecation-shim
+tzlocal==4.2
+    # via streamlit
+urllib3==1.26.13
+    # via requests
+validators==0.20.0
+    # via streamlit
+watchdog==2.2.0
+    # via streamlit
+wheel==0.38.4
+    # via
+    #   nvidia-cublas-cu11
+    #   nvidia-cuda-runtime-cu11
+zipp==3.11.0
+    # via
+    #   importlib-metadata
+    #   importlib-resources
+
+# The following packages are considered to be unsafe in a requirements file:
+# setuptools

src/bible_loader.py

@@ -0,0 +1,37 @@
+import pandas as pd
+import streamlit as st
+from loguru import logger
+
+
+@st.cache()
+def load_bible(metadata_csv, verses_csv):
+    # There is one constant metadata file (metadata_csv),
+    #   and another csv file containing the actual verses in the specified version (bible_csv).
+    metadata_df = pd.read_csv(metadata_csv)
+    verses_df = pd.read_csv(verses_csv, escapechar="\\")
+    df = pd.merge(verses_df, metadata_df, on="b")
+    df = df.fillna("")  # Some verses are blank in some versions
+
+    df = df[["n", "c", "v", "t_x", "t_y"]]
+
+    # The data sources used have this convention in the columns.
+    # Renaming them here for ease of remembrance.
+    col_rename = {
+        "t_y": "testament",
+        "n": "book",
+        "c": "chapter",
+        "v": "verse",
+        "t_x": "text",
+    }
+    df = df.rename(columns=col_rename)
+
+    # Create a human-friendly string of specifying a verse (e.g. Genesis 1:1)
+    df["source"] = df.apply(
+        lambda row: f"{row['book']} {row['chapter']}:{row['verse']}", axis=1
+    )
+
+    logger.info(
+        f"Successfully loaded Bible DF with {len(df):,} rows. Columns: {df.columns.tolist()}"
+    )
+
+    return df

src/embeddings.py

@@ -0,0 +1,60 @@
+import os
+import traceback
+
+import h5py
+import numpy as np
+from loguru import logger
+from sentence_transformers import SentenceTransformer
+
+
+class EmbeddingsManager:
+    def __init__(self, model_name, bible_version, texts, embeddings_cache_dir) -> None:
+
+        # Load embeddings model
+        self.model = SentenceTransformer(model_name)
+
+        # Load or generate embeddings baseed on the corpus
+        sanitized_model_name = model_name.replace("\\", "-").replace("/", "-")
+        self.cache_filename = f"{bible_version}_{sanitized_model_name}.h5"
+        self.emb_cache_filepath = os.path.join(
+            embeddings_cache_dir, self.cache_filename
+        )
+
+        # Load embeddings if it exists
+        try:
+            with h5py.File(self.emb_cache_filepath, "r") as h:
+                self.embeddings = np.array(h["embeddings"])
+        except Exception:
+            traceback.print_exc()
+            # If it doesn't, generate embeddings and save to a file
+            logger.info(
+                f"Generating embeddings and saving to {self.emb_cache_filepath}"
+            )
+            self.embeddings = self.model.encode(texts)
+            with h5py.File(self.emb_cache_filepath, "w") as f:
+                f.create_dataset("embeddings", data=self.embeddings)
+
+        # Create a look-up dict to quickly retrieve embeddings of texts
+        self.text_emb_dict = {}
+        for text, embedding in zip(texts, self.embeddings):
+            self.text_emb_dict[text] = embedding
+
+        logger.info(
+            f"Successfully loaded {model_name} embeddings for {bible_version} from {self.emb_cache_filepath}."
+        )
+
+    def get_embeddings(self, texts):
+        embeddings = []
+        for text in texts:
+            if text not in self.text_emb_dict:
+                self.text_emb_dict[text] = self.model.encode([text])[0]
+            embeddings.append(self.text_emb_dict[text])
+        return embeddings
+
+    def __str__(self):
+        return self.emb_cache_filepath
+
+
+def score_semantic_similarity(query, texts_df):
+    """Returns copy of text_df with semantic similarity scores."""
+    pass

src/models.py

@@ -0,0 +1,36 @@
+import urllib
+
+import pandas as pd
+from pydantic import BaseModel
+
+
+class Chapter(BaseModel):
+    book_name: str
+    chapter_num: int
+    verses_df: pd.DataFrame
+    highlight_verses_df: pd.DataFrame
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def __str__(self) -> str:
+        return f"{self.book_name} {self.chapter_num}"
+
+    def get_formatted_text(self):
+
+        # Construct chapter text
+        texts = []
+        for _, row in self.verses_df.iterrows():
+            text = row["text"]
+            if text in self.highlight_verses_df["text"].tolist():
+                text = f"**:green[{text}]**"
+            text = f"<sup>{row['verse']}</sup> {text}"
+            texts.append(text)
+        chapter_text = " ".join(texts)
+        return chapter_text
+
+    def get_biblegateway_url(self, version="NIV"):
+        return f"https://www.biblegateway.com/passage/?search={urllib.parse.quote(self.book_name)}+{self.chapter_num}&version={version}"
+
+    def get_num_unique_highlight_verse(self):
+        return len(self.highlight_verses_df.drop_duplicates(subset="text"))

src/reranker.py

@@ -0,0 +1,69 @@
+from typing import List
+
+import numpy as np
+import streamlit as st
+
+from src.models import Chapter
+
+
+class Reranker:
+    def rerank(self, chapters: List[Chapter]) -> List[Chapter]:
+        # TODO
+        return chapters
+
+
+# Rerankers applicable to SemanticRetriever results
+
+
+def sort_chapters(chapters, scores):
+    reranked_chapters = sorted(zip(chapters, scores), key=lambda x: x[1], reverse=True)
+    reranked_chapters = [x[0] for x in reranked_chapters]
+    return reranked_chapters
+
+
+class CombinedScoreAndNumberReranker(Reranker):
+    def __init__(self, num_verse_weight=0.3, semantic_sim_weight=0.7):
+        self.num_verse_weight = num_verse_weight
+        self.semantic_sim_weight = semantic_sim_weight
+
+    def rerank(self, chapters: List[Chapter]) -> List[Chapter]:
+        num_verse_score = compute_num_verse_scores(chapters)
+        max_sem_sim_score = compute_sem_sim_scores(chapters)
+
+        final_scores = (
+            self.num_verse_weight * num_verse_score
+            + self.semantic_sim_weight * max_sem_sim_score
+        )
+        return sort_chapters(chapters, final_scores)
+
+
+class SemanticSimScoreReranker(Reranker):
+    def rerank(self, chapters: List[Chapter]) -> List[Chapter]:
+        sem_sim_scores = np.array(
+            [chapter.highlight_verses_df["score"].max() for chapter in chapters]
+        )
+        return sort_chapters(chapters, sem_sim_scores)
+
+
+class MaxVerseReranker(Reranker):
+    def rerank(self, chapters: List[Chapter]) -> List[Chapter]:
+
+        num_verses = [chapter.get_num_unique_highlight_verse() for chapter in chapters]
+
+        return sort_chapters(chapters, num_verses)
+
+
+def compute_num_verse_scores(chapters):
+    num_verses = np.array(
+        [chapter.get_num_unique_highlight_verse() for chapter in chapters]
+    )
+    max_verses = max(num_verses)
+    num_verse_scores = num_verses / max_verses
+    return num_verse_scores
+
+
+def compute_sem_sim_scores(chapters):
+    sem_sim_scores = np.array(
+        [chapter.highlight_verses_df["score"].max() for chapter in chapters]
+    )
+    return sem_sim_scores

src/retriever.py

@@ -0,0 +1,162 @@
+import abc
+from typing import List
+
+import numpy as np
+import pandas as pd
+import sklearn
+import streamlit as st
+from sentence_transformers.cross_encoder import CrossEncoder
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.preprocessing import MinMaxScaler
+from sparse_dot_topn import awesome_cossim_topn
+
+from src.models import Chapter
+
+
+class Retriever:
+    @abc.abstractmethod
+    def retrieve(self, query, n=10) -> List[Chapter]:
+        pass
+
+
+class SemanticRetriever:
+    def __init__(
+        self,
+        bible_df,
+        embeddings_manager,
+        threshold=0.4,
+        cross_encoder_model="cross-encoder/ms-marco-MiniLM-L-12-v2",
+    ):
+        self.bible_df = bible_df
+        self.embeddings_manager = embeddings_manager
+        self.threshold = threshold
+        self.cross_encoder_model = (
+            CrossEncoder(cross_encoder_model) if cross_encoder_model else None
+        )
+
+        # 'cross-encoder/stsb-distilroberta-base'
+        # cross-encoder/ms-marco-MiniLM-L-12-v2
+
+    def retrieve(self, query, n=10) -> List[Chapter]:
+
+        verse_candidates_df = self.semantic_search(
+            query=query,
+            texts=self.bible_df["text"].tolist(),
+            embeddings_manager=self.embeddings_manager,
+            n=n * 2,
+            threshold=self.threshold,
+        )
+
+        if len(verse_candidates_df) == 0:
+            return []
+
+        if self.cross_encoder_model is not None:
+            verse_candidates_df = self.cross_encode(
+                query, verse_candidates_df["text"].tolist()
+            )
+
+        # TODO: revisit this logic as some verses can have the same exact text
+        # For now, workaround is to drop duplicates
+        verse_candidates_df.drop_duplicates(subset="text", inplace=True)
+
+        # Join back verse metadata
+        verse_candidates_df = pd.merge(
+            verse_candidates_df, self.bible_df, how="left", on="text"
+        )
+        # DEBUG
+        # st.write(verse_candidates_df)
+
+        chapter_candidates = self.extract_chapters_from_verses(
+            self.bible_df, verse_candidates_df
+        )
+        return chapter_candidates
+
+    def cross_encode(self, query, texts):
+        combinations = [[query, text] for text in texts]
+        sim_scores = self.cross_encoder_model.predict(combinations)
+        sim_scores = MinMaxScaler().fit_transform(sim_scores.reshape(-1, 1)).flatten()
+        reranked_texts_scores = sorted(
+            zip(texts, sim_scores), key=lambda x: x[1], reverse=True
+        )
+        df = pd.DataFrame(reranked_texts_scores, columns=["text", "score"])
+        return df
+
+    def semantic_search(self, query, texts, embeddings_manager, n=None, threshold=0):
+        embeddings = embeddings_manager.get_embeddings(texts)
+        query_embedding = embeddings_manager.get_embeddings([query])
+        sim_scores = sklearn.metrics.pairwise.cosine_similarity(
+            query_embedding, embeddings
+        )[0]
+
+        # Results is a list of tuples: [(text, score)]
+        results = sorted(list(zip(texts, sim_scores)), key=lambda x: x[1], reverse=True)
+
+        # Take top n only if specified
+        if n:
+            results = results[:n]
+
+        # Apply a threshold to filter irrelevant results
+        if threshold:
+            results = [x for x in results if x[1] >= threshold]
+
+        df = pd.DataFrame(results, columns=["text", "score"])
+
+        return df
+
+    def extract_chapters_from_verses(self, bible_df, verse_results_df) -> List[Chapter]:
+        # Simple, naive assumption now is to just follow order of first appearance
+        # I.e. The per-verse scores dictate the order
+        # TODO: Revisit ranking
+
+        # The goal here is to extract all the unique chapters based on the top verse results
+        verse_results_df = verse_results_df.copy()
+        verse_results_df["book_chapter"] = (
+            verse_results_df["book"] + " " + verse_results_df["chapter"].astype(str)
+        )
+        unique_chapters = verse_results_df["book_chapter"].unique()
+
+        bible_df = bible_df.copy()
+        bible_df["book_chapter"] = (
+            bible_df["book"] + " " + bible_df["chapter"].astype(str)
+        )
+
+        chapters = []
+        for unique_chapter in unique_chapters:
+            chapter_verses_df = bible_df[bible_df["book_chapter"] == unique_chapter]
+            book = chapter_verses_df["book"].tolist()[0]
+            chapter = chapter_verses_df["chapter"].tolist()[0]
+
+            # Keep track of the matched verses as highlight verses
+            highlight_verses_df = pd.merge(
+                chapter_verses_df,
+                verse_results_df[["text", "score", "book", "chapter"]],
+                how="inner",
+                on=["text", "book", "chapter"],
+            )
+
+            chapter = Chapter(
+                book_name=book,
+                chapter_num=chapter,
+                verses_df=chapter_verses_df,
+                highlight_verses_df=highlight_verses_df,
+            )
+
+            chapters.append(chapter)
+
+        return chapters
+
+
+class TfIdfRetriever(Retriever):
+    def __init__(self, texts, preprocessors=[]) -> None:
+        self.vectorizer = TfidfVectorizer(analyzer="word", stop_words="english")
+        self.preprocessors = preprocessors
+        # TODO: pre-process the texts
+        self.tfidf_vectors = self.vectorizer.fit_transform(texts)
+        self.tfidf_vectors_transposed = self.tfidf_vectors.transpose()
+
+    def search(self, query, n=10):
+        query_tfidf_vector = self.vectorizer.transform([query])
+        results = awesome_cossim_topn(
+            query_tfidf_vector, self.tfidf_vectors_transposed, n, 0.01
+        )
+        return results