init

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+Hermes-2-Pro-Llama-3-8B-Q4_K_M.gguf filter=lfs diff=lfs merge=lfs -text

Hermes-2-Pro-Llama-3-8B-Q4_K_M.gguf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:10c52a4820137a35947927be741bb411a9200329367ce2590cc6757cd98e746c
+size 4920916288

app.py

@@ -0,0 +1,71 @@
+import warnings
+
+import streamlit as st
+from dotenv import load_dotenv
+
+from src.chat_rag_agent import ChatRagAgent
+from src.utils import render_chat_history, get_render_assistant_message
+
+warnings.filterwarnings("ignore")
+
+load_dotenv()
+
+st.set_page_config(
+    page_icon="images/logo2.png",
+    initial_sidebar_state="collapsed"
+
+)
+
+
+@st.cache_resource(show_spinner=False)
+def get_chat_rag_agent():
+    return ChatRagAgent()
+
+
+def calc_progress_perc():
+    return min(round(st.session_state["ctx_len"] / chat_rag_agent.n_ctx * 100), 100)
+
+
+def pbar_callback():
+    pbar.progress(calc_progress_perc(), "Chat history limit")
+
+
+with st.spinner("Engine loading"):
+    chat_rag_agent = get_chat_rag_agent()
+
+if "messages" not in st.session_state or st.sidebar.button("Clear chat history"):
+    st.session_state["input_blocked"] = False
+    st.session_state["messages"] = []
+    st.session_state["ctx_len"] = 0
+    st.title("Christian compass")
+    st.markdown("What theological questions you have?")
+
+pbar = st.sidebar.progress(calc_progress_perc(), "Chat history limit")
+
+user_message = st.chat_input(disabled=st.session_state["input_blocked"])
+if user_message:
+    if not st.session_state["input_blocked"]:
+        (message_generator, n_tokens), sources = chat_rag_agent.chat(
+            st.session_state["messages"],
+            user_message
+        )
+        st.session_state["ctx_len"] = n_tokens
+        st.session_state["messages"].append(
+            {
+                "role": "user",
+                "content": user_message
+            }
+        )
+    render_chat_history()
+    if not st.session_state["input_blocked"]:
+        pbar_callback()
+        message = get_render_assistant_message(message_generator, sources, pbar_callback)
+        st.session_state["messages"].append(
+            {
+                "role": "assistant",
+                "content": message
+            }
+        )
+if st.session_state["ctx_len"] >= chat_rag_agent.n_ctx:
+    st.session_state["input_blocked"] = True
+    st.info("Chat history limit reached")

requirements.txt

@@ -0,0 +1,6 @@
+huggingface-hub
+llama-cpp-python
+streamlit
+sentence-transformers
+weaviate-client
+python-dotenv

src/chat_rag_agent.py

@@ -0,0 +1,53 @@
+import os
+
+import weaviate
+from sentence_transformers import SentenceTransformer, CrossEncoder
+
+from src.llama_cpp_chat_engine import LlamaCPPChatEngine
+
+
+class ChatRagAgent:
+    def __init__(self):
+        # self._chat_engine = LlamaCPPChatEngine("Phi-3-mini-4k-instruct-q4.gguf")
+        self._chat_engine = LlamaCPPChatEngine("Hermes-2-Pro-Llama-3-8B-Q4_K_M.gguf")
+        self.n_ctx = self._chat_engine.n_ctx
+        self._vectorizer = SentenceTransformer(
+            "jinaai/jina-embeddings-v2-base-en",
+            trust_remote_code=True
+        )
+
+        self._reranker = CrossEncoder(
+            "jinaai/jina-reranker-v1-turbo-en",
+            trust_remote_code=True,
+        )
+
+        self._collection = weaviate.connect_to_wcs(
+            cluster_url=os.getenv("WCS_URL"),
+            auth_credentials=weaviate.auth.AuthApiKey(os.getenv("WCS_KEY")),
+        ).collections.get("Collection")
+
+    def chat(self, messages, user_message):
+        embedding = self._vectorizer.encode(user_message).tolist()
+        docs = self._collection.query.near_vector(
+            near_vector=embedding,
+            limit=10
+        )
+        ranks = self._reranker.rank(
+            user_message,
+            [i.properties['answer'] for i in docs.objects],
+            top_k=2,
+            apply_softmax=True
+        )
+        context = [
+            f"""\
+            Question: {docs.objects[rank['corpus_id']].properties['question']}
+            Answer: {docs.objects[rank['corpus_id']].properties['answer']}
+            """
+            for rank in ranks if rank["score"] > 0.2
+        ]
+
+        sources = [
+            docs.objects[rank['corpus_id']].properties['link']
+            for rank in ranks if rank["score"] > 0.2
+        ]
+        return self._chat_engine.chat(messages, user_message, context), sources

src/const.py

@@ -0,0 +1,12 @@
+CHAT_AVATARS = {
+    "user": "👤",
+    "assistant": "images/logo2.png"
+}
+
+SYSTEM_PROMPT = """You are a Christian apologetics chatbot designed to answer theological and philosophical questions exclusively from an orthodox Christian perspective, as defined by the historic creeds and confessions of the church. When you receive a question, you will be provided with a few-shot context in the format "Question: ... Answer: ..." to help guide your response.
+You must strictly follow the context provided and base your answers only on the information given. If the context does not provide sufficient information to answer a complex question, you should refuse to answer and say something like "I'm sorry, but I don't have enough contextual information to adequately address that question."
+In your responses, you must adhere to conservative, orthodox Christian theology as expressed in the Bible and historic church tradition. Avoid liberal theological beliefs that contradict or undermine core Christian doctrines. Focus on clearly articulating and defending traditional Christian teachings.
+As a Christian chatbot, you MUST ABSOLUTELY REFUSE to acknowledge any other religions as true or valid. Christianity is the one true faith, and all other religious claims are false. Do not affirm, validate, or promote any non-Christian beliefs.
+You MUST NOT help with any questions that are unrelated to theology or philosophy. Your purpose is solely to address theological and philosophical inquiries from a Christian perspective. If someone asks a question unrelated to these topics, politely inform them that you are designed specifically for Christian apologetics and cannot assist with other subjects.
+If a question challenges or argues against Christian beliefs, respond with logical arguments, biblical evidence, and appeals to respected Christian thinkers and theologians in church history. Maintain a respectful and compassionate tone, but do not compromise on essential Christian truth claims.
+Your purpose is to help people understand the coherence and rationality of the Christian worldview, addressing doubts and questions through sound reasoning, evidence, and theology."""

src/llama_cpp_chat_engine.py

@@ -0,0 +1,59 @@
+from llama_cpp import Llama
+from llama_cpp.llama_chat_format import Jinja2ChatFormatter
+
+from src.const import SYSTEM_PROMPT
+
+
+class LlamaCPPChatEngine:
+    def __init__(self, model_path):
+        self._model = Llama(
+            model_path=model_path,
+            n_ctx=0,
+            verbose=False,
+        )
+        self.n_ctx = self._model.context_params.n_ctx
+        self._eos_token = self._model._model.token_get_text(
+            int(self._model.metadata['tokenizer.ggml.eos_token_id'])
+        )
+        self._formatter = Jinja2ChatFormatter(
+            template=self._model.metadata['tokenizer.chat_template'],
+            bos_token=self._model._model.token_get_text(
+                int(self._model.metadata['tokenizer.ggml.bos_token_id'])
+            ),
+            eos_token=self._eos_token,
+            stop_token_ids=self._model.metadata['tokenizer.ggml.eos_token_id']
+        )
+
+        self._tokenizer = self._model.tokenizer()
+
+    def chat(self, messages, user_message, context):
+        if context:
+            user_message_extended = "\n".join(context + [f"Question: {user_message}"])
+        else:
+            user_message_extended = user_message
+        messages = (
+                [
+                    {
+                        "role": "system",
+                        "content": SYSTEM_PROMPT
+                    }
+                ] + messages + [
+                    {
+                        "role": "user",
+                        "content": user_message_extended,
+
+                    }
+                ]
+        )
+        prompt = self._formatter(messages=messages).prompt
+        tokens = self._tokenizer.encode(prompt, add_bos=False)
+        n_tokens = len(tokens)
+        response_generator = self._model.create_completion(
+            tokens,
+            stop=self._eos_token,
+            max_tokens=self.n_ctx - n_tokens,
+            stream=True,
+            temperature=0
+        )
+
+        return response_generator, n_tokens

src/utils.py

@@ -0,0 +1,27 @@
+import streamlit as st
+
+from src.const import CHAT_AVATARS
+
+
+def render_chat_history():
+    for message in st.session_state["messages"]:
+        with st.chat_message(message['role'], avatar=CHAT_AVATARS[message['role']]):
+            st.write(message['content'])
+
+
+def get_render_assistant_message(message_generator, sources, callback):
+    assistant_message = []
+
+    def gen_patched():
+        for chunk in message_generator:
+            st.session_state["ctx_len"] += 1
+            callback()
+            text = chunk['choices'][0]["text"]
+            assistant_message.append(text)
+            yield text
+    with st.chat_message('assistant', avatar=CHAT_AVATARS['assistant']):
+        st.write_stream(gen_patched())
+        for source in sources:
+            st.write(source)
+        st.caption("AI can make mistakes. Please, fact check the answers")
+    return "".join(assistant_message)