Delete rag_chain

rag_chain/__init__.py

@@ -1 +0,0 @@
-

rag_chain/chain.py

@@ -1,186 +0,0 @@
-import os
-import random
-from functools import cache
-from operator import itemgetter
-
-import langsmith
-from langchain.memory import ConversationBufferWindowMemory
-from langchain.retrievers import EnsembleRetriever
-from langchain_community.document_transformers import LongContextReorder
-from langchain_core.documents import Document
-from langchain_core.output_parsers import StrOutputParser
-from langchain_core.runnables import RunnableLambda
-from langchain_openai.chat_models import ChatOpenAI
-
-from .prompt_template import generate_prompt_template
-from .retrievers_setup import (
-    DenseRetrieverClient,
-    SparseRetrieverClient,
-    compression_retriever_setup,
-    multi_query_retriever_setup,
-)
-
-# Helpers
-
-
-def reorder_documents(docs: list[Document]) -> list[Document]:
-    """Reorder documents to mitigate performance degradation with long contexts."""
-    return LongContextReorder().transform_documents(docs)
-
-
-def randomize_documents(documents: list[Document]) -> list[Document]:
-    """Randomize documents to vary model recommendations."""
-    random.shuffle(documents)
-    return documents
-
-
-class DocumentFormatter:
-    def __init__(self, prefix: str):
-        self.prefix = prefix
-
-    def __call__(self, docs: list[Document]) -> str:
-        """Format the Documents to markdown.
-        Args:
-            docs (list[Documents]): List of Langchain documents
-        Returns:
-            docs (str):
-        """
-        return f"\n---\n".join(
-            [
-                f"- {self.prefix} {i+1}:\n\n\t" + d.page_content
-                for i, d in enumerate(docs)
-            ]
-        )
-
-
-def create_langsmith_client():
-    """Create a Langsmith client."""
-    os.environ["LANGCHAIN_TRACING_V2"] = "true"
-    os.environ["LANGCHAIN_PROJECT"] = "talltree-ai-assistant"
-    os.environ["LANGCHAIN_ENDPOINT"] = "https://api.smith.langchain.com"
-    langsmith_api_key = os.getenv("LANGCHAIN_API_KEY")
-    if not langsmith_api_key:
-        raise EnvironmentError("Missing environment variable: LANGCHAIN_API_KEY")
-    return langsmith.Client()
-
-
-# Set up Runnable and Memory
-
-
-@cache
-def get_rag_chain(
-    model_name: str = "gpt-4", temperature: float = 0.2
-) -> tuple[ChatOpenAI, ConversationBufferWindowMemory]:
-    """Set up runnable and chat memory
-
-    Args:
-        model_name (str, optional): LLM model. Defaults to "gpt-4" 30012024.
-        temperature (float, optional): Model temperature. Defaults to 0.2.
-
-    Returns:
-        Runnable, Memory: Chain and Memory
-    """
-
-    RETRIEVER_PARAMETERS = {
-        "embeddings_model": "text-embedding-3-small",
-        "k_dense_practitioners_db": 8,
-        "k_sparse_practitioners_db": 15,
-        "weights_ensemble_practitioners_db": [0.2, 0.8],
-        "k_compression_practitioners_db": 12,
-        "k_dense_talltree": 6,
-        "k_compression_talltree": 6,
-    }
-
-    # Set up Langsmith to trace the chain
-    langsmith_tracing = create_langsmith_client()
-
-    # LLM and prompt template
-    llm = ChatOpenAI(
-        model_name=model_name,
-        temperature=temperature,
-    )
-
-    prompt = generate_prompt_template()
-
-    # Set retrievers pointing to the practitioners's dataset
-    dense_retriever_client = DenseRetrieverClient(
-        embeddings_model=RETRIEVER_PARAMETERS["embeddings_model"],
-        collection_name="practitioners_db",
-        search_type="similarity",
-        k=RETRIEVER_PARAMETERS["k_dense_practitioners_db"],
-    )  # k x 4 using multiquery retriever
-
-    # Qdrant db as a retriever
-    practitioners_db_dense_retriever = dense_retriever_client.get_dense_retriever()
-
-    # Multiquery retriever using the dense retriever
-    # This retriever can be passed or not to the EnsembleRetriever. It uses GPT-3.5-turbo.
-    practitioners_db_dense_multiquery_retriever = multi_query_retriever_setup(
-        practitioners_db_dense_retriever
-    )
-
-    # Sparse vector retriever
-    sparse_retriever_client = SparseRetrieverClient(
-        collection_name="practitioners_db_sparse_collection",
-        vector_name="sparse_vector",
-        splade_model_id="naver/splade-cocondenser-ensembledistil",
-        k=RETRIEVER_PARAMETERS["k_sparse_practitioners_db"],
-    )
-
-    practitioners_db_sparse_retriever = sparse_retriever_client.get_sparse_retriever()
-
-    # Ensemble retriever for hyprid search (dense retriever seems to work better but the dense retriever is good for acronyms like RMT)
-    practitioners_ensemble_retriever = EnsembleRetriever(
-        retrievers=[
-            practitioners_db_dense_retriever,
-            practitioners_db_sparse_retriever,
-        ],
-        weights=RETRIEVER_PARAMETERS["weights_ensemble_practitioners_db"],
-    )
-
-    # Compression retriever for practitioners db
-    practitioners_db_compression_retriever = compression_retriever_setup(
-        practitioners_ensemble_retriever,
-        embeddings_model=RETRIEVER_PARAMETERS["embeddings_model"],
-        k=RETRIEVER_PARAMETERS["k_compression_practitioners_db"],
-    )
-
-    # Set retrievers pointing to the tall_tree_db
-    dense_retriever_client = DenseRetrieverClient(
-        embeddings_model=RETRIEVER_PARAMETERS["embeddings_model"],
-        collection_name="tall_tree_db",
-        search_type="similarity",
-        k=RETRIEVER_PARAMETERS["k_dense_talltree"],
-    )
-
-    tall_tree_db_dense_retriever = dense_retriever_client.get_dense_retriever()
-
-    # Compression retriever for tall_tree_db
-    tall_tree_db_compression_retriever = compression_retriever_setup(
-        tall_tree_db_dense_retriever,
-        embeddings_model=RETRIEVER_PARAMETERS["embeddings_model"],
-        k=RETRIEVER_PARAMETERS["k_compression_talltree"],
-    )
-
-    # Set conversation history window memory. It only uses the last k interactions.
-    memory = ConversationBufferWindowMemory(
-        memory_key="history",
-        return_messages=True,
-        k=6,
-    )
-
-    # Set up runnable using LCEL
-    setup_and_retrieval = {
-        "practitioners_db": itemgetter("message")
-        | practitioners_db_compression_retriever
-        | DocumentFormatter("Practitioner #"),
-        "tall_tree_db": itemgetter("message")
-        | tall_tree_db_dense_retriever
-        | DocumentFormatter("No."),
-        "history": RunnableLambda(memory.load_memory_variables) | itemgetter("history"),
-        "message": itemgetter("message"),
-    }
-
-    chain = setup_and_retrieval | prompt | llm | StrOutputParser()
-
-    return chain, memory

rag_chain/prompt_template.py

@@ -1,95 +0,0 @@
-from langchain.prompts import (
-    ChatPromptTemplate,
-    MessagesPlaceholder,
-    SystemMessagePromptTemplate,
-)
-
-
-def generate_prompt_template():
-
-    system_template = """# Role
-
----
-
-Your name is Ella (Empathetic, Logical, Liaison, Accessible). You are a helpful Virtual Assistant at Tall Tree Health in British Columbia, Canada. Based on the patient's symptoms/needs, connect them with the appropriate practitioner or service offered by Tall Tree. Respond to `Patient Queries` using the `Practitioners Database` and `Tall Tree Health Centre Information` provided in the `Context`. Follow the `Response Guidelines` listed below:
-
----
-
-# Response Guidelines
-
-1. **Interaction**: Engage in a warm, empathetic, and professional manner. Keep responses brief and focused on the patient's query. Always conclude positively with a reassuring statement. Use markdown formatting.
-
-2. **Symptoms/needs and Location Preference**: Only if not specified, ask for symptoms/needs and location preference (Cordova Bay, James Bay, and Vancouver) before recommending a practitioner or service.
-
-3. **Avoid Making Assumptions**: Stick to the given `Context`. If you're unable to assist, offer the user the contact details for the closest `Tall Tree Health` clinic.
-
-4. Do not give medical advice or act as a health professional. Avoid discussing healthcare costs.
-
-5. **Symptoms/needs and Service Verification**: Match the patient's symptoms/needs with the `Focus Area` field in the `Practitioners Database`. If no match is found, advise the patient accordingly without recommending a practitioner, as Tall Tree is not a primary healthcare provider.
-
-6. **Recommending Practitioners**: Based on the patient's symptoms/needs and location, randomly recommend up to 3 practitioners (only with active status) from the `Practitioners Database`. Focus on `Discipline`, `Focus Areas`, `Location`, `Treatment Method`,`Status`, and `Populations in Focus`. Once you recommend a practitioner, provide the contact info for the corresponding `Tall Tree Health` location for additional assistance.
-
-7. **Practitioner's Contact Information**: Provide contact information in the following structured format. Do not print their `Focus Areas`:
-
-    - `First Name` and `Last Name`
-    - `Discipline`
-    - `Booking Link` (print only if available)
-
-## Tall Tree Health Service Routing Guidelines
-
-8. **Mental Health Urgent Queries**: For urgent situations such as self-harm, suicidal thoughts, violence, hallucinations, or dissociation direct the patient to call the [9-8-8](tel:9-8-8) suicide crisis helpline, reach out to the Vancouver Island Crisis Line at [1-888-494-3888](tel:1-888-494-3888), or head to the nearest emergency room. Tall Tree isn't equipped for mental health emergencies. Do not recommend a practitioner or service.
-
-9. **Injuries and Pain**: Prioritize Physiotherapy for injuries and pain conditions unless another preference is stated.
-
-10. **Concussion Protocol**: Direct to the `Concussion Treatment Program` for the appropriate location for a comprehensive assessment with a physiotherapist. Do not recommend a practitioner.
-
-11. **Psychologist in Vancouver**: If a Psychologist is requested in the Vancouver location, provide only the contact and booking link for our mental health team in Cordova Bay - Upstairs location. Do not recommend an alternative practitioner.
-
-12. **Sleep issues**: Recommend only the Sleep Program intake and provide the phone number to book an appointment. Do not recommend a practitioner.
-
-13. **Longevity Program**: For longevity queries, provide the Longevity Program phone number. Do not recommend a practitioner.
-
-14. **DEXA Testing or body composition**: Inform that this service is exclusive to the Cordova Bay clinic and provide the clinic phone number and booking link. Do not recommend a practitioner.
-
-15. **For VO2 Max Testing**: Determine the patient's location preference for Vancouver or Victoria and provide the booking link for the appropriate location. If Victoria, we only do it at our Cordova Bay location.
-
----
-
-# Patient Query
-
-```
-{message}
-```
----
-
-# Context
-
----
-1. **Practitioners Database**:
-
-```
-{practitioners_db}
-```
----
-
-2. **Tall Tree Health Centre Information**:
-
-```
-{tall_tree_db}
-```
----
-
-"""
-
-    # Template for system message with markdown formatting
-    system_message = SystemMessagePromptTemplate.from_template(system_template)
-
-    prompt = ChatPromptTemplate.from_messages(
-        [
-            system_message,
-            MessagesPlaceholder(variable_name="history"),
-            ("human", "{message}"),
-        ]
-    )
-
-    return prompt

rag_chain/retrievers_setup.py

@@ -1,196 +0,0 @@
-import os
-from functools import cache
-
-import qdrant_client
-import torch
-from langchain.prompts import PromptTemplate
-from langchain.retrievers import ContextualCompressionRetriever
-from langchain.retrievers.document_compressors import EmbeddingsFilter
-from langchain.retrievers.multi_query import MultiQueryRetriever
-from langchain_community.retrievers import QdrantSparseVectorRetriever
-from langchain_community.vectorstores import Qdrant
-from langchain_openai import ChatOpenAI
-from langchain_openai.embeddings import OpenAIEmbeddings
-from transformers import AutoModelForMaskedLM, AutoTokenizer
-
-
-class ValidateQdrantClient:
-    """Base class for retriever clients to ensure environment variables are set."""
-
-    def __init__(self):
-        self.validate_environment_variables()
-
-    def validate_environment_variables(self):
-        """Check if the Qdrant environment variables are set."""
-        required_vars = ["QDRANT_API_KEY", "QDRANT_URL"]
-        missing_vars = [var for var in required_vars if not os.getenv(var)]
-        if missing_vars:
-            raise EnvironmentError(
-                f"Missing environment variable(s): {', '.join(missing_vars)}"
-            )
-
-
-class DenseRetrieverClient(ValidateQdrantClient):
-    """Initialize the dense retriever using OpenAI text embeddings and Qdrant vector database."""
-
-    TEXT_EMBEDDING_MODELS = [
-        "text-embedding-ada-002",
-        "text-embedding-3-small",
-        "text-embedding-3-large",
-    ]
-
-    def __init__(
-        self,
-        embeddings_model="text-embedding-3-small",
-        collection_name="practitioners_db",
-        search_type="similarity",
-        k=4,
-    ):
-        super().__init__()
-        if embeddings_model not in self.TEXT_EMBEDDING_MODELS:
-            raise ValueError(
-                f"Invalid embeddings model: {embeddings_model}. Valid options are {', '.join(self.TEXT_EMBEDDING_MODELS)}."
-            )
-        self.embeddings_model = embeddings_model
-        self.collection_name = collection_name
-        self.search_type = search_type
-        self.k = k
-        self.client = qdrant_client.QdrantClient(
-            url=os.getenv("QDRANT_URL"),
-            api_key=os.getenv("QDRANT_API_KEY"),
-            prefer_grpc=True,
-        )
-        self._qdrant_collection = None
-
-    def set_qdrant_collection(self, embeddings):
-        """Prepare the Qdrant collection for the embeddings model."""
-        return Qdrant(
-            client=self.client,
-            collection_name=self.collection_name,
-            embeddings=embeddings,
-        )
-
-    @property
-    @cache
-    def qdrant_collection(self):
-        """Load Qdrant collection for a given embeddings model."""
-        if self._qdrant_collection is None:
-            self._qdrant_collection = self.set_qdrant_collection(
-                OpenAIEmbeddings(model=self.embeddings_model)
-            )
-        return self._qdrant_collection
-
-    def get_dense_retriever(self):
-        """Set up retrievers (Qdrant vectorstore as retriever)."""
-        return self.qdrant_collection.as_retriever(
-            search_type=self.search_type, search_kwargs={"k": self.k}
-        )
-
-
-class SparseRetrieverClient(ValidateQdrantClient):
-    """Initialize the sparse retriever using the SPLADE neural retrieval model and Qdrant vector database."""
-
-    def __init__(
-        self,
-        collection_name,
-        vector_name,
-        splade_model_id="naver/splade-cocondenser-ensembledistil",
-        k=15,
-    ):
-
-        # Validate Qdrant client
-        super().__init__()
-        self.client = qdrant_client.QdrantClient(
-            url=os.getenv("QDRANT_URL"), api_key=os.getenv("QDRANT_API_KEY")
-        )  # TODO: prefer_grpc=True is not working
-        self.model_id = splade_model_id
-        self._tokenizer = None
-        self._model = None
-        self.collection_name = collection_name
-        self.vector_name = vector_name
-        self.k = k
-
-    @property
-    @cache
-    def tokenizer(self):
-        """Initialize the tokenizer."""
-        if self._tokenizer is None:
-            self._tokenizer = AutoTokenizer.from_pretrained(self.model_id)
-        return self._tokenizer
-
-    @property
-    @cache
-    def model(self):
-        """Initialize the SPLADE neural retrieval model."""
-        if self._model is None:
-            self._model = AutoModelForMaskedLM.from_pretrained(self.model_id)
-        return self._model
-
-    def sparse_encoder(self, text: str) -> tuple[list[int], list[float]]:
-        """Encode the input text into a sparse vector."""
-        tokens = self.tokenizer(
-            text,
-            return_tensors="pt",
-            max_length=512,
-            padding="max_length",
-            truncation=True,
-        )
-
-        with torch.no_grad():
-            logits = self.model(**tokens).logits
-
-        relu_log = torch.log1p(torch.relu(logits))
-        weighted_log = relu_log * tokens.attention_mask.unsqueeze(-1)
-
-        max_val = torch.max(weighted_log, dim=1).values.squeeze()
-        indices = torch.nonzero(max_val, as_tuple=False).squeeze().cpu().numpy()
-        values = max_val[indices].cpu().numpy()
-
-        return indices.tolist(), values.tolist()
-
-    def get_sparse_retriever(self) -> QdrantSparseVectorRetriever:
-        """Return a Qdrant vector sparse retriever."""
-
-        return QdrantSparseVectorRetriever(
-            client=self.client,
-            collection_name=self.collection_name,
-            sparse_vector_name=self.vector_name,
-            sparse_encoder=self.sparse_encoder,
-            k=self.k,
-        )
-
-
-def compression_retriever_setup(
-    base_retriever, embeddings_model="text-embedding-3-small", k=20
-):
-    """Creates a ContextualCompressionRetriever with an EmbeddingsFilter."""
-    filter = EmbeddingsFilter(embeddings=OpenAIEmbeddings(model=embeddings_model), k=k)
-
-    return ContextualCompressionRetriever(
-        base_compressor=filter, base_retriever=base_retriever
-    )
-
-
-def multi_query_retriever_setup(retriever):
-    """Configure a multi-query retriever using a base retriever."""
-
-    prompt = PromptTemplate(
-        input_variables=["question"],
-        template="""
-        
-        Your task is to generate 3 different grammatically correct versions of the provided text,
-        incorporating the user's location preference in each version. Format these versions as paragraphs and present them as items in a Markdown formatted numbered list ("1. "). There should be no additional new lines or spaces between each version. Do not enclose your response in quotation marks. Do not modify unfamiliar acronyms and keep your responses clear and concise.
-        
-        **Notes**: The text provided are user questions to Tall Tree Health Centre's AI virtual assistant. `Location preference:` is the location of the Tall Tree Health clinic that the user prefers.
-
-        Text to be modified:
-        ```
-        {question}
-        ```""",
-    )
-
-    llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
-
-    return MultiQueryRetriever.from_llm(
-        retriever=retriever, llm=llm, prompt=prompt, include_original=True
-    )