Copy from previous failed (docker issue) Gardio space - to a new space (also correcting the previous typo in space name)

.gitattributes

@@ -1,35 +1,35 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz 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
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz 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

README.md

@@ -1,13 +1,27 @@
----
-title: Hebrew Dentist
-emoji: 🐨
-colorFrom: blue
-colorTo: purple
-sdk: gradio
-sdk_version: 5.49.1
-app_file: app.py
-pinned: false
-short_description: A RAG Agent which works as a Hebrew speaking dentist
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Hebrew Dentsit
+emoji: 🏢
+colorFrom: blue
+colorTo: red
+sdk: gradio
+sdk_version: 5.10.0
+app_file: app.py
+pinned: false
+short_description: A RAG agent Hebrew Speaking Dentist
+---
+
+Do you want to consult with a Dentist? Speaking Hebrew? Consulting with Dentist can be expensive... This is why I had built a Hebrew RAG Dentist Agent, which you can talk to. 
+
+Warning: The Agent (Chatbot) can still hallucinate and make up "fake" facts and shouldn’t be an alternative for an expert Dentist. the use of this Chatbot is on your responsibility only.  
+
+This RAG Agent based on Q&A data collected from 3 top Israeli forums. Data was collected using scraper, and saved into a SQL DB. Then, the titles & questions were embedded into vectors using free 'MPA/sambert' HuggingFace Encoder Model (this model found to be performing well on Hebrew Medical Jargon). The Vectors were stored a hundread at a time, into NoSQL Pinecone Vector Database, with answer_id as metadata.
+The answers were converted into vector embedding using the same free Encoder ('MPA/sambert'), and stored in Pinecone with different key and with the answer as metadata
+Now, all is left is the the RAG Agent which is composed from a Retriever, Reranker, and a Generator:
+4)	The Retriever embeds the user question (using the free 'MPA/sambert' HuggingFace Encoder Model) uses an ANN search with a cosine similarity metric and the top_k variable equals to 50.
+5)	The Reranker fetches the answers vectors suing their list of top_k ids and answers as metadata in a second scan from the PineCone database resorts the answers, then cosine similarity is calculated using the sklearn method. Afterwards, it selects the the top_n (equal to 5) answers, when each answer should be similar to the question embedding with a threshold of 0.7 or higher.
+6)	The Generator used is from a paid API -Anthropic Claude Sonnet 3.5 - a decoder that is not trained over the medical jargon - however with the right prompt and the right context the results are pretty good.
+
+The whole work from inception to completion was done by me (Eli Borodach)
+
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,117 @@
+import gradio as gr
+import time
+
+
+from rag_agent import RAGAgent
+
+
+rag_agent = RAGAgent()
+
+
+class ChatBot:
+    def __init__(self, rag_agent):
+        self.message_history = []
+        self.rag_agent = rag_agent
+
+    def get_response(self, message):
+        return self.rag_agent.get_response(message)
+
+    def chat(self, message):
+        time.sleep(1)
+        bot_response = self.get_response(message)
+        self.message_history.append((message, bot_response))
+        return bot_response
+
+
+def create_chat_interface(rag_agent=rag_agent):
+    chatbot = ChatBot(rag_agent=rag_agent)
+
+    custom_css = """
+    #chatbot {
+        direction: rtl;
+        height: 400px;
+    }
+    .message {
+        font-size: 16px;
+        text-align: right;
+    }
+    .message-wrap {
+        direction: rtl !important;
+    }
+    .message-wrap > div {
+        direction: rtl !important;
+        text-align: right !important;
+    }
+    .input-box {
+        direction: rtl !important;
+        text-align: right !important;
+    }
+    .container {
+        direction: rtl;
+    }
+    .contain {
+        direction: rtl !important;
+    }
+    .bubble {
+        direction: rtl !important;
+        text-align: right !important;
+    }
+    textarea, input {
+        direction: rtl !important;
+        text-align: right !important;
+    }
+    .user-message, .bot-message {
+        direction: rtl !important;
+        text-align: right !important;
+    }
+    """
+
+    with gr.Blocks(css=custom_css) as interface:
+        with gr.Column(elem_classes="container"):
+            gr.Markdown("רופא שיניים אלקטרוני", rtl=True)
+
+            chatbot_component = gr.Chatbot(
+                [],
+                elem_id="chatbot",
+                height=400,
+                rtl=True,
+                elem_classes="message-wrap"
+            )
+
+            with gr.Row():
+                submit_btn = gr.Button("שלח", variant="primary")
+                txt = gr.Textbox(
+                    show_label=False,
+                    placeholder="הקלד את ההודעה שלך כאן...",
+                    container=False,
+                    elem_classes="input-box",
+                    rtl=True
+                )
+
+            clear_btn = gr.Button("נקה צ'אט")
+
+        def user_message(user_message, history):
+            return "", history + [[user_message, None]]
+
+        def bot_message(history):
+            user_message = history[-1][0]
+            bot_response = chatbot.chat(user_message)
+            history[-1][1] = bot_response
+            return history
+
+        def clear_summary():
+            rag_agent.conversation_summary = ""
+            rag_agent.messages = []
+
+        submit_btn.click(user_message, [txt, chatbot_component], [txt, chatbot_component], queue=False).then(
+            bot_message, chatbot_component, chatbot_component
+        )
+
+        clear_btn.click(clear_summary, None, chatbot_component, queue=False)
+
+    return interface
+
+
+# Launch the interface
+chat_interface = create_chat_interface(rag_agent=rag_agent)
+chat_interface.launch(share=True)

generator.py

@@ -0,0 +1,63 @@
+from retriever import Retriever
+from reranker import Reranker
+from anthropic import Anthropic
+from typing import List
+import os
+
+
+retriever = Retriever()
+reranker = Reranker()
+
+
+class RAGAgent:
+    def __init__(
+            self,
+            retriever=retriever,
+            reranker=reranker,
+            anthropic_api_key: str = os.environ["anthropic_api_key"],
+            model: str = "claude-3-5-sonnet-20241022",
+            max_tokens: int = 1024,
+            temperature: float = 0.0,
+    ):
+        self.retriever = retriever
+        self.reranker = reranker
+        self.client = Anthropic(api_key=anthropic_api_key)
+        self.model = model
+        self.max_tokens = max_tokens
+        self.temperature = temperature
+
+    def get_context(self, query: str) -> List[str]:
+        # Get initial candidates from retriever
+        retrieved_docs = self.retriever.search_similar(query)
+
+        # Rerank the candidates
+        context = self.reranker.rerank(query, retrieved_docs)
+
+        return context
+
+    def generate_prompt(self, context: List[str]) -> str:
+        context = "\n".join(context)
+        prompt = f"""
+                    "אתה רופא שיניים, דובר עברית בלבד. קוראים לך 'רופא השיניים העברי האלקטרוני הראשון'. ענה למטופל על השאלה שלו על סמך הקונטקס הבא: {context}. הוסף כמה שיותר פרטים, ודאג שהתחביר יהיה תקין ויפה. תעצור כשאתה מרגיש שמיצית את עצמך. אל תמציא דברים. ואל תענה בשפות שהן לא עברית.
+                 """
+        return prompt
+
+    def get_response(self, question: str) -> str:
+        # Get relevant context
+        context = self.get_context(question)
+
+        # Generate prompt with context
+        prompt = self.generate_prompt(context)
+
+        # Get response from Claude
+        response = self.client.messages.create(
+            model=self.model,
+            max_tokens=self.max_tokens,
+            temperature=self.temperature,
+            messages=[
+                        {"role": "assistant", "content": prompt},
+                        {"role": "user", "content": f"{question}"}
+                    ]
+        )
+
+        return response.content[0].text

rag_agent.py

@@ -0,0 +1,125 @@
+from anthropic import Anthropic
+from typing import List
+import os
+
+
+from retriever import Retriever
+from reranker import Reranker
+from text_embedder_encoder import TextEmbedder, encoder_model_name
+
+
+retriever = Retriever()
+reranker = Reranker()
+
+
+class RAGAgent:
+    def __init__(
+            self,
+            retriever=retriever,
+            reranker=reranker,
+            anthropic_api_key: str = os.environ["anthropic_api_key"],
+            model_name: str = "claude-3-5-sonnet-20241022",
+            max_tokens: int = 1024,
+            temperature: float = 0.0,
+    ):
+        self.retriever = retriever
+        self.reranker = reranker
+        self.client = Anthropic(api_key=anthropic_api_key)
+        self.model_name = model_name
+        self.max_tokens = max_tokens
+        self.temperature = temperature
+        self.text_embedder = TextEmbedder()
+        self.conversation_summary = ""
+        self.messages = []
+
+    def get_context(self, query: str) -> List[str]:
+        # Get initial candidates from retriever
+        query_vector = self.text_embedder.encode(query)
+        retrieved_answers_ids = self.retriever.search_similar(query_vector)
+        # Rerank the candidates
+        context = self.reranker.rerank(query_vector, retrieved_answers_ids)
+
+        return context
+
+    def generate_prompt(self, context: List[str], conversation_summary: str = "") -> str:
+        context = "\n".join(context)
+        summary_context = f"\nסיכום השיחה עד כה:\n{conversation_summary}" if conversation_summary else ""
+
+        prompt = f"""
+                    אתה רופא שיניים, דובר עברית בלבד. קוראים לך 'רופא השיניים האלקטרוני העברי הראשון'.{summary_context}
+                    ענה למטופל על השאלה שלו על סמך הקונטקס הבא: {context}. 
+                    הוסף כמה שיותר פרטים, ודאג שהתחביר יהיה תקין ויפה. 
+                    תעצור כשאתה מרגיש שמיצית את עצמך. אל תמציא דברים. 
+                    ואל תענה בשפות שהן לא עברית.
+                 """
+        return prompt
+
+    def update_summary(self, question: str, answer: str) -> str:
+        """Update the conversation summary with the new interaction"""
+        summary_prompt = {
+            "model": self.model_name,
+            "max_tokens": 500,
+            "temperature": 0.0,
+            "messages": [
+                {
+                    "role": "user",
+                    "content": f"""סכם את השיחה בעברית, הנה סיכום השיחה עד כה:
+{self.conversation_summary if self.conversation_summary else "אין שיחה קודמת."}
+
+אינטראקציה חדשה:
+שאלת המטופל: {question}
+תשובת הרופא: {answer}
+
+אנא ספק סיכום מעודכן שכולל את המידע הרפואי מהסיכום הקודם בנוסף לדגש על האינטרקציה החדשה. הסיכום צריך להיות תמציתי עד 100 מילה.
+ותר על מידע לא רלוונטי מהסיכומים הקודמים"""
+                }
+            ]
+        }
+
+        try:
+            response = self.client.messages.create(**summary_prompt)
+            self.conversation_summary = response.content[0].text
+            return self.conversation_summary
+        except Exception as e:
+            print(f"Error updating summary: {e}")
+            return self.get_basic_summary()
+
+    def get_basic_summary(self) -> str:
+        """Fallback method for basic summary"""
+        summary = []
+        for i in range(0, len(self.messages), 2):
+            if i + 1 < len(self.messages):
+                summary.append(f"שאלת המטופל: {self.messages[i]['content']}")
+                summary.append(f"תשובת הרופא שיניים: {self.messages[i + 1]['content']}\n")
+        return "\n".join(summary)
+
+    def get_response(self, question: str) -> str:
+        # Get relevant context
+        context = self.get_context(question + self.conversation_summary)
+
+        # Generate prompt with context and current conversation summary
+        prompt = self.generate_prompt(context, self.conversation_summary)
+
+        # Get response from Claude
+        response = self.client.messages.create(
+            model=self.model_name,
+            max_tokens=self.max_tokens,
+            temperature=self.temperature,
+            messages=[
+                {"role": "assistant", "content": prompt},
+                {"role": "user", "content": f"{question}"}
+            ]
+        )
+
+        answer = response.content[0].text
+
+        # Store messages for history
+        self.messages.extend([
+            {"role": "user", "content": question},
+            {"role": "assistant", "content": answer}
+        ])
+
+        # Update conversation summary
+        self.update_summary(question, answer)
+
+        return answer

requirements.txt

@@ -0,0 +1,4 @@
+anthropic==0.42.0
+gradio==4.44.1
+pinecone==5.4.2
+sentence-transformers==3.2.1

reranker.py

@@ -0,0 +1,37 @@
+from pinecone import Pinecone
+from sklearn.metrics.pairwise import cosine_similarity
+import os
+
+
+from text_embedder_encoder import encoder_model_name
+
+
+class Reranker:
+    def __init__(self,
+                 pinecone_api_key=os.environ["pinecone_api_key"],
+                 answer_index_name=f"hebrew-dentist-answers-{encoder_model_name.replace('/', '-')}".lower()):
+        self.pc = Pinecone(api_key=pinecone_api_key)
+        self.answer_index_name = answer_index_name
+
+    def rerank(self, query_vector, retrieved_answers_ids, top_n=5):
+        # Encode query and documents
+        try:
+            index = self.pc.Index(self.answer_index_name)
+            fetch_response = index.fetch(ids=retrieved_answers_ids)
+
+            doc_embeddings = []
+            answers = []
+            for i in range(len(retrieved_answers_ids)):
+                doc_embeddings.append(fetch_response['vectors'][retrieved_answers_ids[i]]['values'])
+                answers.append(fetch_response['vectors'][retrieved_answers_ids[i]]['metadata']['answer'])
+
+            similarity_scores = cosine_similarity([query_vector], doc_embeddings)[0]
+            similarity_scores_with_idxes = list(zip(similarity_scores, range(len(similarity_scores))))
+            similarity_scores_with_idxes.sort(reverse=True)
+            similarity_scores_with_idxes_final = similarity_scores_with_idxes[:top_n]
+            reranked_answers = [answers[idx] for score, idx in similarity_scores_with_idxes_final if score >= 0.7]
+
+            return reranked_answers
+        except Exception as e:
+            print(f"Error performing rerank: {e}")
+            return []

retriever.py

@@ -0,0 +1,39 @@
+from pinecone import Pinecone
+import os
+
+from text_embedder_encoder import encoder_model_name
+
+
+class Retriever:
+    def __init__(self,
+                 pinecone_api_key=os.environ["pinecone_api_key"],
+                 question_index_name=f"hebrew-dentist-questions-{encoder_model_name.replace('/', '-')}".lower()):
+        # Initialize Pinecone connection
+        self.pc = Pinecone(api_key=pinecone_api_key)
+        self.question_index_name = question_index_name
+
+    def search_similar(self, query_vector, top_k=50):
+        """
+        Search for similar content using vector similarity in Pinecone
+        """
+        try:
+
+            # Get Pinecone index
+            index = self.pc.Index(self.question_index_name)
+
+            # Execute search
+            results = index.query(
+                vector=query_vector,
+                top_k=top_k,
+                include_metadata=True,
+            )
+
+            answers_records_ids = []
+            for match in results['matches']:
+                answers_records_ids.append(
+                    ':'.join(match['id'].split(':')[:-1]) + ":" + str(int(match['metadata']['answer_id'])))
+
+            return answers_records_ids
+        except Exception as e:
+            print(f"Error performing retriever: {e}")
+            return []

text_embedder_encoder.py

@@ -0,0 +1,55 @@
+import torch
+import numpy as np
+from sentence_transformers import SentenceTransformer
+
+
+encoder_model_name = 'MPA/sambert'
+
+
+class TextEmbedder:
+    def __init__(self):
+        """
+        Initialize the Hebrew text embedder using dictabert-large-heq model
+        """
+        # self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = SentenceTransformer(encoder_model_name)
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.model.to(self.device)
+        self.model.eval()
+
+    def encode(self, text) -> np.ndarray:
+        """
+            Encode Hebrew text using LaBSE model with handling for texts longer than max_seq_length.
+
+            Args:
+                text (str): Hebrew text to encode
+                model_name (str): Name of the model to use
+                # max_seq_length (int): Maximum sequence length for the model
+                strategy (str): Strategy for combining sentence embeddings ('mean' or 'concat')
+
+            Returns:
+                numpy.ndarray: Text embedding
+            """
+        # Get embeddings for the text
+        embeddings = [float(x) for x in self.model.encode([text])[0]]
+
+        return embeddings
+
+    # def encode_many(self, texts: List[str]) -> np.ndarray:
+    #     """
+    #         Encode Hebrew text using LaBSE model with handling for texts longer than max_seq_length.
+    #
+    #         Args:
+    #             text (str): Hebrew text to encode
+    #             model_name (str): Name of the model to use
+    #             # max_seq_length (int): Maximum sequence length for the model
+    #             strategy (str): Strategy for combining sentence embeddings ('mean' or 'concat')
+    #
+    #         Returns:
+    #             numpy.ndarray: Text embedding
+    #         """
+    #     # Get embeddings for the text
+    #     embeddings = self.model.encode(texts)
+    #     embeddings = [[float(x) for x in embedding] for embedding in embeddings]
+    #
+    #     return embeddings